{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 定义算法\n",
    "\n",
    "NoisyDQN 是在 DQN 的基础上进行改进，主要就是通过在训练网络的时候加上一些噪声参数，可以用较小的额外计算成本，在强化学习算法上获得更优的结果。\n",
    "配置和 DQN 基本一致，只是在模型定义的时候，在模型中加入了一些噪声参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1、 定义模型\n",
    "这里使用了一个三层的MLP，不同的是其中加入了一些噪声参数，就是每个权值weight和偏置bias中都有额外的参数mu和sigma，这里仅供参考。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class NoisyLinear(nn.Module):\n",
    "    def __init__(self, input_dim, output_dim, std_init=0.4):\n",
    "        super(NoisyLinear, self).__init__()\n",
    "        \n",
    "        self.input_dim  = input_dim\n",
    "        self.output_dim = output_dim\n",
    "        self.std_init     = std_init\n",
    "        \n",
    "        self.weight_mu    = nn.Parameter(torch.FloatTensor(output_dim, input_dim))\n",
    "        self.weight_sigma = nn.Parameter(torch.FloatTensor(output_dim, input_dim))\n",
    "        self.register_buffer('weight_epsilon', torch.FloatTensor(output_dim, input_dim))\n",
    "        \n",
    "        self.bias_mu    = nn.Parameter(torch.FloatTensor(output_dim))\n",
    "        self.bias_sigma = nn.Parameter(torch.FloatTensor(output_dim))\n",
    "        self.register_buffer('bias_epsilon', torch.FloatTensor(output_dim))\n",
    "        \n",
    "        self.reset_parameters()\n",
    "        self.reset_noise()\n",
    "    \n",
    "    def forward(self, x):\n",
    "        if self.training: \n",
    "            weight = self.weight_mu + self.weight_sigma.mul(torch.tensor(self.weight_epsilon))\n",
    "            bias   = self.bias_mu   + self.bias_sigma.mul(torch.tensor(self.bias_epsilon))\n",
    "        else:\n",
    "            weight = self.weight_mu\n",
    "            bias   = self.bias_mu\n",
    "        \n",
    "        return F.linear(x, weight, bias)\n",
    "    \n",
    "    def reset_parameters(self):\n",
    "        mu_range = 1 / math.sqrt(self.weight_mu.size(1))\n",
    "        \n",
    "        self.weight_mu.data.uniform_(-mu_range, mu_range)\n",
    "        self.weight_sigma.data.fill_(self.std_init / math.sqrt(self.weight_sigma.size(1)))\n",
    "        \n",
    "        self.bias_mu.data.uniform_(-mu_range, mu_range)\n",
    "        self.bias_sigma.data.fill_(self.std_init / math.sqrt(self.bias_sigma.size(0)))\n",
    "    \n",
    "    def reset_noise(self):\n",
    "        epsilon_in  = self._scale_noise(self.input_dim)\n",
    "        epsilon_out = self._scale_noise(self.output_dim)\n",
    "        \n",
    "        self.weight_epsilon.copy_(epsilon_out.ger(epsilon_in))\n",
    "        self.bias_epsilon.copy_(self._scale_noise(self.output_dim))\n",
    "    \n",
    "    def _scale_noise(self, size):\n",
    "        x = torch.randn(size)\n",
    "        x = x.sign().mul(x.abs().sqrt())\n",
    "        return x\n",
    "\n",
    "class NoisyMLP(nn.Module):\n",
    "    def __init__(self, input_dim,output_dim,hidden_dim=128):\n",
    "        super(NoisyMLP, self).__init__()\n",
    "        self.fc1 =  nn.Linear(input_dim, hidden_dim)\n",
    "        self.noisy_fc2 = NoisyLinear(hidden_dim, hidden_dim)\n",
    "        self.noisy_fc3 = NoisyLinear(hidden_dim, output_dim)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.noisy_fc2(x))\n",
    "        x = self.noisy_fc3(x)\n",
    "        return x\n",
    "\n",
    "    def reset_noise(self):\n",
    "        self.noisy_fc2.reset_noise()\n",
    "        self.noisy_fc3.reset_noise()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2、定义经验回放\n",
    "\n",
    "这里的经验回放和DQN中保持一致，也是具有一定容量，只有存储到一定的transition网络才会更新。经验回放的时候一般包涵两个功能或方法，一个是push，即将一个transition样本按顺序放到经验回放中，如果满了就把最开始放进去的样本挤掉；另外一个是sample，就是随机采样出一个或者若干个（具体多少就是batch_size了）样本供DQN网络更新。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "class ReplayBuffer(object):\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        ''' 存储transition到经验回放中\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量，则取经验回放的容量\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # 顺序采样\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else: # 随机采样\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def clear(self):\n",
    "        ''' 清空经验回放\n",
    "        '''\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "        ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3、模型算法定义\n",
    "\n",
    "这里根据前面的噪声MLP搭建智能体agent，其中的动作采样和模型更新和DQN基本一致，这里不再赘述。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "\n",
    "class NoisyDQN:\n",
    "    def __init__(self, model, memory, cfg) -> None:\n",
    "        self.n_actions = cfg.n_actions  \n",
    "        self.device = torch.device(cfg.device) \n",
    "        self.gamma = cfg.gamma  \n",
    "        ## e-greedy策略相关参数\n",
    "        self.sample_count = 0  # 用于epsilon的衰减计数\n",
    "        self.epsilon = cfg.epsilon_start\n",
    "        self.epsilon_start = cfg.epsilon_start\n",
    "        self.epsilon_end = cfg.epsilon_end\n",
    "        self.epsilon_decay = cfg.epsilon_decay\n",
    "        self.batch_size = cfg.batch_size\n",
    "        self.target_update = cfg.target_update\n",
    "\n",
    "        self.device = torch.device(cfg.device) \n",
    "\n",
    "        self.policy_net = model.to(self.device)\n",
    "        self.target_net = model.to(self.device)\n",
    "        ## 复制参数到目标网络\n",
    "        for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "            target_param.data.copy_(param.data)\n",
    "        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr)\n",
    "        self.memory = memory ## 经验回放\n",
    "        self.update_flag = False\n",
    "        \n",
    "    def sample_action(self, state):\n",
    "        ''' sample action with e-greedy policy \n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        # epsilon 指数衰减\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.sample_count / self.epsilon_decay) \n",
    "        if random.random() > self.epsilon:\n",
    "            with torch.no_grad():\n",
    "                state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "                q_values = self.policy_net(state)\n",
    "                action = q_values.max(1)[1].item() # 根据Q值选择动作\n",
    "        else:\n",
    "            action = random.randrange(self.n_actions)\n",
    "        return action\n",
    "\n",
    "    @torch.no_grad()\n",
    "    def predict_action(self, state):\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        q_value = self.policy_net(state)\n",
    "        action  = q_value.max(1)[1].item()\n",
    "        return action\n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 不满足一个批量时，不更新策略\n",
    "            return\n",
    "        else:\n",
    "            if not self.update_flag:\n",
    "                print(\"Begin to update!\")\n",
    "                self.update_flag = True\n",
    "        # beta = min(1.0, self.beta_start + self.sample_count * (1.0 - self.beta_start) / self.beta_frames)\n",
    "        state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        # state_batch, action_batch, reward_batch, next_state_batch, done_batch, weights_batch, indices = self.memory.sample(self.batch_size, beta) \n",
    "        state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float) \n",
    "        action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1)\n",
    "        reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float).unsqueeze(1)\n",
    "        next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float) # shape(batchsize,n_states)\n",
    "        done_batch = torch.tensor(done_batch, device=self.device, dtype=torch.float).unsqueeze(1)\n",
    "        # weights_batch = torch.tensor(weights_batch, device=self.device, dtype=torch.float)\n",
    "\n",
    "        q_value_batch = self.policy_net(state_batch).gather(dim=1, index=action_batch) # shape(batchsize,1),requires_grad=True\n",
    "        next_max_q_value_batch = self.target_net(next_state_batch).max(1)[0].detach().unsqueeze(1) \n",
    "        expected_q_value_batch = reward_batch + self.gamma * next_max_q_value_batch* (1-done_batch)\n",
    "\n",
    "        loss = nn.MSELoss()(q_value_batch, expected_q_value_batch)  # shape same to  \n",
    "        # 反向传播\n",
    "        self.optimizer.zero_grad()  \n",
    "        loss.backward()\n",
    "        # 梯度截断，防止梯度爆炸\n",
    "        for param in self.policy_net.parameters():  \n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optimizer.step() \n",
    "\n",
    "        if self.sample_count % self.target_update == 0: # 更新 target_net\n",
    "            self.target_net.load_state_dict(self.policy_net.state_dict())   \n",
    "\n",
    "        ## 噪声参数重置\n",
    "        self.policy_net.reset_noise()\n",
    "        self.target_net.reset_noise()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2、 定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(cfg, env, agent):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    print(\"开始训练！\")\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state = env.reset()  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            action = agent.sample_action(state)  # 选择动作\n",
    "            next_state, reward, done, _ = env.step(action)  # 更新环境，返回transition\n",
    "            agent.memory.push((state, action, reward,next_state, done))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            agent.update()  # 更新智能体\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if done:\n",
    "                break\n",
    "        if (i_ep + 1) % cfg.target_update == 0:  # 智能体目标网络更新\n",
    "            agent.target_net.load_state_dict(agent.policy_net.state_dict())\n",
    "        steps.append(ep_step)\n",
    "        rewards.append(ep_reward)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，Epislon：{agent.epsilon:.3f}\")\n",
    "    print(\"完成训练！\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards}\n",
    "\n",
    "def test(cfg, env, agent):\n",
    "    print(\"开始测试！\")\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []\n",
    "    for i_ep in range(cfg.test_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state = env.reset()  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step+=1\n",
    "            action = agent.predict_action(state)  # 选择动作\n",
    "            next_state, reward, done, _ = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if done:\n",
    "                break\n",
    "        steps.append(ep_step)\n",
    "        rewards.append(ep_reward)\n",
    "        print(f\"回合：{i_ep+1}/{cfg.test_eps}，奖励：{ep_reward:.2f}\")\n",
    "    print(\"完成测试\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import os\n",
    "def all_seed(env,seed = 1):\n",
    "    ''' 万能的seed函数\n",
    "    '''\n",
    "    env.seed(seed) # env config\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False\n",
    "def env_agent_config(cfg):\n",
    "    env = gym.make(cfg.env_name) # 创建环境\n",
    "    if cfg.seed !=0:\n",
    "        all_seed(env,seed=cfg.seed)\n",
    "    n_states = env.observation_space.shape[0]\n",
    "    n_actions = env.action_space.n\n",
    "    print(f\"状态空间维度：{n_states}，动作空间维度：{n_actions}\")\n",
    "\n",
    "    cfg.n_actions = env.action_space.n  ## set the env action space\n",
    "    model = NoisyMLP(n_states, n_actions, hidden_dim = cfg.hidden_dim) # 创建模型\n",
    "    memory = ReplayBuffer(cfg.buffer_size)\n",
    "    agent = NoisyDQN(model,memory,cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4、设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "class Config():\n",
    "    def __init__(self) -> None:\n",
    "        self.env_name = \"CartPole-v1\" # 环境名字\n",
    "        self.new_step_api = True # 是否用gym的新api\n",
    "        self.wrapper = None \n",
    "        self.render = False \n",
    "        self.algo_name = \"NoisyDQN\" # 算法名字\n",
    "        self.mode = \"train\" # train or test\n",
    "        self.seed = 0 # 随机种子\n",
    "        self.device = \"cpu\" # device to use\n",
    "        self.train_eps = 100 # 训练的回合数\n",
    "        self.test_eps = 20 # 测试的回合数\n",
    "        self.eval_eps = 10 # 评估的回合数\n",
    "        self.eval_per_episode = 5 # 每个回合的评估次数\n",
    "        self.max_steps = 200 # 每个回合的最大步数\n",
    "        self.load_checkpoint = False\n",
    "        self.load_path = \"tasks\" # 加载模型的路径\n",
    "        self.show_fig = False # 是否展示图片\n",
    "        self.save_fig = True # 是否存储图片\n",
    "\n",
    "\n",
    "        # 设置epsilon值\n",
    "        self.epsilon_start = 0.95 # 起始的epsilon值\n",
    "        self.epsilon_end = 0.01 # 终止的epsilon值\n",
    "        self.epsilon_decay = 500 # 衰减率\n",
    "        self.hidden_dim = 256 \n",
    "        self.gamma = 0.95 \n",
    "        self.lr = 0.0001 \n",
    "        self.buffer_size = 100000 # 经验回放的buffer大小\n",
    "        self.batch_size = 64 # batch size\n",
    "        self.target_update = 4 # 目标网络更新频率\n",
    "        self.value_layers = [\n",
    "            {'layer_type': 'linear', 'layer_dim': ['n_states', 256],\n",
    "             'activation': 'relu'},\n",
    "            {'layer_type': 'linear', 'layer_dim': [256, 256],\n",
    "             'activation': 'relu'},\n",
    "            {'layer_type': 'linear', 'layer_dim': [256, 'n_actions'],\n",
    "             'activation': 'none'}]\n",
    "\n",
    "def smooth(data, weight=0.9):  \n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(rewards,cfg, tag='train'):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set()\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{tag}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")\n",
    "    plt.xlabel('epsiodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5、开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "状态空间维度：4，动作空间维度：2\n",
      "开始训练！\n",
      "Begin to update!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/dingli/anaconda3/envs/joyrl/lib/python3.7/site-packages/ipykernel_launcher.py:26: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "/home/dingli/anaconda3/envs/joyrl/lib/python3.7/site-packages/ipykernel_launcher.py:27: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "回合：10/100，奖励：11.00，Epislon：0.711\n",
      "回合：20/100，奖励：18.00，Epislon：0.498\n",
      "回合：30/100，奖励：20.00，Epislon：0.359\n",
      "回合：40/100，奖励：20.00，Epislon：0.214\n",
      "回合：50/100，奖励：94.00，Epislon：0.049\n",
      "回合：60/100，奖励：200.00，Epislon：0.011\n",
      "回合：70/100，奖励：200.00，Epislon：0.010\n",
      "回合：80/100，奖励：200.00，Epislon：0.010\n",
      "回合：90/100，奖励：200.00，Epislon：0.010\n",
      "回合：100/100，奖励：200.00，Epislon：0.010\n",
      "完成训练！\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi4AAAHPCAYAAAB0ulFlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAACyCUlEQVR4nOzdd3xUVfr48c+dmjppJKGElkDoEFCqiAqIUiy7iq4NrKurKOr6W1l33dUt6rru1wJWZC3YGxYEbCAooixIEakSaijpvUy59/fH5E4yySSZTDKTwvN+vXxJZm45czNz88w5z3mOommahhBCCCFEB2Bo6wYIIYQQQvhLAhchhBBCdBgSuAghhBCiw5DARQghhBAdhgQuQgghhOgwJHARQgghRIchgYsQQgghOgwJXIQQQgjRYUjgIoQQQogOQwKXTmjy5MksWLAgoH2vueYarrnmmlZukRD1ffjhh5x//vkMGTKE008/vU3a0JLPSmdTVlbGn/70J8444wwGDBjAP//5z7ZuUof0ww8/MGDAAH744Ye2bkqnZWrrBpyKfvzxR9avX8/cuXOx2Wxt3RwhQm7//v388Y9/5Mwzz+S3v/0tYWFhDW67cOFCFi1aREJCAl999RXh4eFez0+ePJn+/fvz/PPPB7vZzbJgwQKWLVvm+TkiIoL4+HiGDBnCzJkzOffcczEY6n931DSNjz76iHfffZc9e/bgcDjo1asX06dP57rrrqv3+q+55ho2btzIOeecw3PPPef13NGjR5kyZQp/+MMfuOGGGxpt7/PPP8+yZcu49dZb6dmzJ2lpaS149f5xuVx8+OGHfPjhh+zZs4fy8nKSkpIYO3YsV155JcOGDWu1czV23508eTJZWVmen+Pj4+nbty/XXXcd5557bqu1IdjeeOMNvv/+e7Zv387x48f51a9+xSOPPNLWzWp1Eri0gS1btrBo0SJ+9atfBSVwWbVqFYqiBLTvkiVLWrk1QtS3ceNGVFXlT3/6E7179/Zrn7y8PN58802uv/76VmtHSz4r/rBYLPzjH/8AoKqqiqysLNasWcMdd9zBmDFjePbZZ4mKivJs73K5+P3vf8/KlSs5/fTTmTdvHuHh4WzatImFCxeycuVKXn75ZRISEuqda82aNezYsYOhQ4cG1Nbvv/+eESNGMG/evMBebDNVVlYyb948vvnmG0aPHs3NN99MTEwMWVlZrFy5kmXLlvH111/TtWvXVjlfU/fdQYMGcd111wGQnZ3N22+/zbx583jggQe44oorWqUNwfbiiy9SVlbGsGHDyMnJaevmBI0ELu2cqqo4HA6sVqvf+1gsloDP15J927vy8nIiIiLauhkCdxACEB0d7fc+gwYNYsmSJVx55ZWN9tA0R7Df7yaTiYsuusjrsbvuuosXXniB//znP/z5z3/miSee8Dz34osvsnLlSq6//nruvfdez+OXX34506dP57bbbuOPf/wjL7zwgtcxu3fvTllZGYsWLarX6+KvvLw8+vXrF9C+vjidTlRVbfAaP/roo3zzzTf88Y9/5Nprr/V6bt68ebz88sut0g5/P/fJyclev6uLL76YadOm8fLLL3eYwGXp0qV0794dRVEYOXJkWzcnaCTHJcQWLlzIo48+CsCUKVMYMGAAAwYM4OjRowAMGDCAv/3tb3z88cfMnDmTYcOG8c033wDu3pDf/OY3jB07luHDh/PrX/+aVatW1TtH3XH7Dz74gAEDBrB582Yefvhhxo0bR0ZGBrfddhv5+fle+9bNcdHHa1esWMGzzz7LpEmTGDZsGHPnzuXQoUP1zv36668zZcoUhg8fzqWXXsqmTZualTfz0UcfcemllzJixAhGjx7NVVddxbfffut5fsCAASxcuNDv17xx40YeeOABxo8fz1lnncWqVas8j9f11ltvMWDAAPbu3et5bP/+/Z5vx8OGDePXv/41X331lV+vpby8nEceeYSzzjqLoUOHct5557FkyRLqLsiu/86//PJLZs2axdChQ5k5cybr1q3z6zxVVVUsXLiQ8847j2HDhjFx4kTmzZvH4cOHAfdwwYABA1iyZAkvv/wy55xzDsOHD+fqq6/2eq3QcI7TggULmDx5sl/tef3115k5cyZDhw5l4sSJPPjggxQXF3uenzx5sud3OH78+AZ/p3Xddttt5Obm8uabbza5rb/Xvu77xuFwsGjRIqZNm8awYcMYO3YsV1xxBevXrwfg/fffZ8CAAezcubPeOZ977jkGDRrEyZMnm2zfb3/7WyZOnMiqVas4cOAA4O6BWLJkCX369OH3v/99vX0mT57MxRdfzNq1a9m+fbvXc5GRkcydO5c1a9bw888/N3n+2vTP+NGjR/n666/r3ZPy8vK47777mDBhAsOGDePCCy/0GgKD+u+xqVOnMmzYMPbv3+/znCdOnODtt9/mjDPOqBe0ABiNRm644QZPb0tWVhYPPPAA5513HsOHD2fs2LHccccdnjbqGvrcN3Xf9SUxMZHU1FSvIaSdO3dy4403MmrUKEaOHMncuXPZunVrk9cYYNu2bdxwww2cdtppjBgxgquvvprNmzc3uo/D4WDMmDH88Y9/rPdcaWkpw4YN41//+pfnsR49egS1B7G9kB6XEDv33HM5ePAgy5cv549//CNxcXGAe0xV9/3337Ny5Uquuuoq4uLi6NGjBwCvvvoqkydP5oILLsDhcPDpp58yf/58nn/+ec4+++wmz/2Pf/wDm83GvHnzyMrK4pVXXuFvf/ub1ze+hixevBhFUbj++uspLS3lxRdf5J577uHdd9/1bPPGG2/wt7/9jdNPP51rr72WrKwsbrvtNmw2m1/dvYsWLWLhwoWMHDmSO+64A7PZzLZt2/j++++ZOHFik/v78uCDDxIfH89tt91GeXk5Z599NhEREaxcuZIxY8Z4bbtixQr69+9Peno6APv27eOKK64gOTmZm266ybPfbbfdxsKFCxsd+9Y0jd/97nf88MMPXHrppQwaNIhvvvmGRx99lJMnT3Lfffd5bb9582Y+//xzrrzySiIjI1m6dCl33HEHa9as8bxHfHG5XNx8881s2LCBmTNnMmfOHMrKyli/fj179+6lV69enm0//PBDysrKuPLKK6mqqmLp0qXMnTuXTz75hC5dugRyeevR81EmTJjAFVdcwYEDB3jzzTf56aefePPNNzGbzdx33318+OGHfPHFFzzwwANEREQwYMCAJo992mmnMW7cOF588UWuuOKKBntdmnvta1u0aBHPP/88s2fPZvjw4ZSWlrJjxw5+/vlnzjjjDM477zz+9re/8cknnzB48GCvfT/55BPGjBlDcnKyX9fqwgsv5Ntvv+W7776jb9++bN68maKiIubMmYPJ5PvWfPHFF/PBBx+wevVqhg8f7vXc3LlzeeWVV1i4cGGzel3S0tJ49NFHefjhh+natatnuCQ+Pp7KykquueYaDh8+zFVXXUVKSgqrVq1iwYIFFBcXM3fuXK9jffDBB1RVVXHZZZdhsViIiYnxec5169bhdDq58MIL/WrjTz/9xJYtW5g5cyZdu3YlKyuLN998kzlz5vDpp5/Wy/up+7mfNGlSk/fduhwOBydOnCA2NhZw3w+uuuoqIiMjufHGGzGZTLz99ttcc801vPbaa4wYMaLBY23YsIGbbrqJoUOHMm/ePBRF4YMPPmDu3Lm88cYb9X6XOrPZzNSpU/niiy948MEHvXqvvvzyS+x2OzNmzPDrGnYqmgi5F198UUtPT9eOHDlS77n09HRt4MCB2r59++o9V1FR4fWz3W7XZs2apc2ZM8fr8XPOOUe79957PT+///77Wnp6unbttddqqqp6Hn/ooYe0QYMGacXFxZ7Hrr76au3qq6/2/Pz9999r6enp2vTp07WqqirP46+88oqWnp6u7dmzR9M0TauqqtLGjBmjXXLJJZrD4fBs98EHH2jp6elex/Tl4MGD2sCBA7XbbrtNc7lcXs/VbnN6err21FNP1du/odd8xRVXaE6n02vbu+++Wxs/frzX49nZ2drAgQO1RYsWeR6bO3euNmvWLK/Xraqqdvnll2vTpk1r9PV88cUXWnp6uvbMM894PX777bdrAwYM0A4dOuT1moYMGeL12K5du7T09HRt6dKljZ7nvffe09LT07WXXnqp3nP6dTty5IiWnp6uDR8+XDtx4oTn+W3btmnp6enaQw895Hms7u9fd++992rnnHNOo23Jy8vThgwZol1//fVev8PXXntNS09P19577z3PY0899ZSWnp6u5eXlNXrMuttu3Lix3us955xztN/+9reen5tz7eu+by688EKvY/ly9913axMnTvR6jT///LOWnp6uvf/++57H7r33Xi0jI6PB4+zcudPr+r/88staenq69sUXXzS4T2FhoZaenq7NmzfP89jVV1+tzZw5U9M0TVu4cKGWnp6u7dixQ9O0mt/9iy++2Ohr0rT617F2mz766CPPY3a7Xbv88su1jIwMraSkxOs8o0aN8ut3+tBDD2np6enazp07m9xW0+rf+zRN07Zs2aKlp6dry5Yt8zzW2Oe+sfvuOeeco11//fVaXl6elpeXp+3atUu76667tPT0dO3vf/+7pmmaduutt2pDhgzRDh8+7Nnv5MmT2siRI7WrrrrK85h+z/z+++81TXN/DqdNm6Zdf/31XveyiooKbfLkydp1113X6Gv/5ptvtPT0dG316tVej990003alClTGtwvIyPD673dmchQUTs0evRon2PNtb9hFhUVUVJSwmmnneaz29qXyy67zKsb8fTTT8flcnl1hTbk17/+tVe0r09fPXLkCAA7duygsLCQyy67zOvb4gUXXNDgt67avvzyS1RV5bbbbqs306IlXZ+XXXYZRqPR67Hp06eTl5fnNVz02Wefoaqq59tLYWEh33//PdOnT6e0tJT8/Hzy8/MpKChg4sSJHDx4sNEhgXXr1mE0GusNu1x//fVomlZvGGjChAlevSMDBw4kKirKc30b8vnnnxMXF8fVV19d77m6123q1KlevQHDhw9nxIgRrF27ttFz+Ou7777D4XAwZ84cr9/h7NmziYqKapXzjB49mrFjx/Liiy9SWVnpc5vmXvvabDYb+/bt4+DBgw1uc9FFF5Gdne013fWTTz4hLCyMadOm+f1a9LyLsrIyr/9HRkY2uI/+nL5tXXPnziUmJoZFixb53Y7GrFu3jsTERGbNmuV5zGw2c80111BeXs7//vc/r+2nTZvWaC+GrrS0FGj8tdZW+97ncDgoKCigV69e2Gw2n/c/X5/7pnz77beMHz+e8ePHc9FFF7Fq1Souuugi7rnnHlwuF+vXr2fq1Kn07NnTs09SUhKzZs1i8+bNntdU165duzh48CAXXHABBQUFnntJeXk548eP53//+x+qqjbYrnHjxhEXF8eKFSs8jxUVFfHdd9+dmr0tyFBRu5SSkuLz8TVr1vDss8+ya9cu7Ha753F//7B3797d62c9s752/kGg+x47dgzA648vuJMT9aGuxhw+fBiDwdDqUzB9XctJkyYRHR3NihUrGD9+POAeJho0aBB9+/b1tEfTNJ588kmefPJJn8fOy8trcFggKyuLpKQkrxkjgOf11Q0Wu3XrVu8YMTExTf5uDh8+TN++fRscWqjN1+ydPn36sHLlyib39Yf+HkhNTfV63GKx0LNnT78CZH/cfvvtXH311bz11ls+8yOae+1ru+OOO7j11ls577zzSE9PZ+LEiVx00UUMHDjQs80ZZ5xBYmIiH3/8MePHj0dVVZYvX86UKVPqnbMx5eXlQM0f76aCktrPNRQcREdHM2fOHBYuXMjOnTtbPGsxKyuL3r171/syoV9L/Xeua+jeVZd+nRp7rbVVVlby/PPP88EHH3Dy5EmvXKWSkpJ62/vbjtpGjBjBnXfeiaIohIWFkZaW5rl+OTk5VFRUeO4PtaWlpaGqKsePH6d///71nteD4NrJ1nWVlJQQHh5OUVGR1+Px8fGYTCamTZvG8uXLsdvtWCwWPv/8cxwOhwQuov3wNXa/adMmfve73zF69Gj++te/kpiYiNls5v3332f58uV+HddXzQigXsJia+8bCi6Xy+fjvmZjWSwWz7jxX//6V/Ly8vjxxx+5++67Pdvo34Cuv/56zjzzTJ/HrhuktURD3w7b+/VtC6NHj2bMmDG8+OKL/OY3v2n1Y3/xxRd89dVXrF+/nvfee49XXnmFBx98kNmzZwPu39UFF1zAO++8wwMPPMCPP/5Idna23/kaOj0xWn8f6b2su3fvZurUqT732bNnD4DXt/669FyXRYsWNZrPEwz+zvbSg9s9e/YwaNCgJrf/+9//7skJycjIIDo6GkVRuOuuu3x+RpozC1MXFxfHhAkTmr1fU/T2/eEPf2jwtUZERPDjjz8yZ84cr8e/+uorUlJSmDlzJm+//Tbr1q1j6tSprFq1itTUVK+A+lQigUsbCGTo47PPPsNqtbJkyRKvIZv333+/NZsWML1H5vDhw4wbN87zuNPpJCsrq8nky169eqGqKvv372/0RuarF8Jutze7ZsH06dNZtmwZGzZsYP/+/WiaxvTp0z3P638YzGZzQDezHj16sGHDBkpLS72+hWdmZnqebw29evVi27ZtOBwOzGZzo9v6mgV28OBBr7bExMT4HJ6q+83aF/09kJmZ6fWH1W63c/To0Vb9o3D77bdzzTXX8NZbb9V7rqXXPjY2lksuuYRLLrmEsrIyrr76ahYuXOgJXMA9XPTf//6X1atXs27dOuLj45udQP7xxx+jKApnnHEGAKNGjcJms7F8+XJ+97vf+QxmP/zwQwDOP//8Bo8bHR3N3LlzWbhwIb/61a+a1aa6evTowZ49e1BV1evLi34t6/bE+mvSpEkYjUY++eQTLr744ia3/+yzz7j44ou9ZoBVVVX57G1pSEuGnOPj4wkPD/fMAKstMzMTg8Hgs9cUau4lUVFRjX4GBg4cyEsvveT1WGJiIuAOqBMTE1mxYgWjRo3i+++/55Zbbgn05XR4kuPSBvQM+OZ86IxGI4qieH3zPXr0qN9Tc4Nt6NChxMbG8s477+B0Oj2Pf/LJJ/W6P32ZOnUqBoOBp59+ut54b+1vVD179mTTpk1ez7/zzjvN7hGYMGECsbGxrFixgpUrVzJ8+HCvP7YJCQmMGTOGt99+m+zs7Hr7151GXtekSZNwuVy8/vrrXo+//PLLKIrCpEmTmtXehkybNo2CgoJ654H6vTVffvmlV17O9u3b2bZtm1dbevbsSWZmptfr2717Nz/++GOTbZkwYQJms5mlS5d6nfu9996jpKSEs846q1mvrTFjxozx9LpUVVV5PdeSa19QUOD1c2RkJL169fIamgX3H5kBAwbw3nvv8fnnnzNz5ky/hut0L7zwAt9++y0zZsygT58+gPu+cOONN3LgwAEef/zxevt8/fXXLFu2jHPOOafJLwJ6ddinn37a7zb5MmnSJHJycrzyK5xOJ0uXLiUiIoLRo0cHdNxu3boxe/Zsvv32W5YuXVrveVVV+e9//8uJEycA3z2SS5cubdbnPpD7rs5oNHLGGWfw1VdfeU2hzs3NZfny5Zx22mkNDhMOHTqUXr168d///tfn0Jj+WYuJiWHChAle/+k9RwaDgfPPP581a9bw8ccf43Q6T9lhIpAelzYxZMgQAB5//HFmzJiB2WzmnHPOabRI0llnncVLL73EjTfeyKxZs8jLy+ONN96gV69enu7jtmSxWLj99tv5+9//zty5c5k+fTpZWVl88MEHfg2p9O7dm1tuuYVnnnmGK6+8kmnTpmGxWPjpp59ISkry1LWYPXs2f/3rX7n99tuZMGECu3fv5ttvv210yrAvZrOZc889l08//ZSKigqf489//etfufLKK7ngggu47LLL6NmzJ7m5uWzdupUTJ07w8ccfN3j8yZMnM3bsWB5//HFPj9P69ev56quvmDt3bqsNM1188cV8+OGHPPzww2zfvp3TTjuNiooKNmzYwBVXXOE15NCrVy+uuOIKrrjiCux2O6+++iqxsbHceOONnm0uvfRSXn75ZW644QYuvfRS8vLyeOutt+jXr1+T+Qjx8fHcfPPNLFq0iBtvvJHJkydz4MAB3njjDU/9j9Y0b968el3r0LJrP3PmTMaMGcOQIUOIjY3lp59+4rPPPvOZ/HzxxRd7amg09NqcTicfffQR4O55ysrKYvXq1ezZs4exY8fyt7/9zWv7G2+8kV27drF48WK2bt3KtGnTCAsLY/PmzXz88cf069fPrxLueq5LS5N0L7/8ct5++20WLFjAzz//TI8ePfjss8/48ccfue+++5qV01PXggULOHLkCP/4xz/4/PPPOeecc7DZbBw/fpxVq1aRmZnJzJkzATj77LP56KOPiIqKol+/fmzdupXvvvvOM1XZH4Hcd2u78847+e6777jyyiu58sorMRqNvP3229jtdv7f//t/De5nMBj4xz/+wU033cSsWbP49a9/TXJyMidPnuSHH34gKirKr+nr06dPZ+nSpTz11FOkp6f7zAdcvXo1u3fvBtxJzHv27OGZZ54B3J+LzjK0JIFLGxg+fDjz58/nrbfe4ptvvkFVVb766qtGP0Djx4/nn//8J4sXL+ahhx4iJSWFe+65h6ysrHYRuABcffXVaJrGSy+9xL/+9S8GDhzIs88+yz/+8Q+/xpznz59PSkoKr732Go8//jjh4eEMGDDAq5rlZZddxtGjR3nvvff45ptvOO2003jppZd8Jmk2ZcaMGbz77rsoiuI1TKTr168f77//PosWLWLZsmUUFhYSHx/P4MGDue222xo9tsFg4Nlnn+Wpp55ixYoVfPDBB/To0YM//OEPrVqy3mg0snjxYp599lmWL1/O559/TmxsLKNGjar3rfziiy/GYDDwyiuvkJeXx/Dhw7n//vtJSkrybJOWlsa//vUvnnrqKR5++GH69evHo48+yvLly30W7avr9ttvJz4+ntdee42HH36YmJgYLrvsMu6+++4mh7Kaa+zYsYwZM6Zeu1py7a+55hpWr17N+vXrsdvtdO/enTvvvNPnOj8XXHABjz32GD179mywDofdbucPf/gD4P7GHx8fz9ChQ7ntttt8rlVkNBp5/PHHOeuss3jnnXd44oknPAHjhAkTeP755/2u9qvnugTSw6ALCwtj6dKlPPbYYyxbtozS0lL69u3Lww8/zK9//euAjwvu67F48WI++OADPvzwQ5555hkqKys9axU99thjnuT3P/3pTxgMBj755BOqqqoYNWqU54ucvwK579bWv39/Xn/9df7zn//w/PPPo2kaw4cP59///nejNVzA/V59++23eeaZZ3jttdcoLy8nMTGR4cOHc/nll/t1/lGjRtGtWzeOHz/eYG/L559/7lUccOfOnZ5ZV127du00gYuitZfsP9EpqarK+PHjOffccz1rtojQas5Ce8J/+fn5nHnmmdx6661NBrIt4XA4uOWWW/j+++891auFOJVJjotoNVVVVfXyKj788EMKCwvrVakVoqNbtmwZLper3lpErc1sNrNw4UIGDhzI/Pnzm13SX4jORoaKRKvZunUrDz/8MOeffz6xsbHs3LmT9957j/T09EZnQQjRkegz0Z577jmmTp0aUM2Q5oqIiGg3MwiFaGsSuIhW06NHD7p27crSpUspKioiJibGU3myM686LU4tzzzzDFu2bGHkyJHcf//9bd0cIU45kuMihBBCiA5DclyEEEII0WFI4CKEEEKIDkMCFyGEEEJ0GJ0uOVfTNFQ1OGk7BoMStGMLb3KtQ0eudejItQ4dudah0xrX2mBQ/F5PqtMFLqqqkZ/v31LpzWEyGYiLi6S4uBynU216BxEwudahI9c6dORah45c69BprWsdHx+J0ehf4CJDRUIIIYToMCRwEUIIIUSHIYGLEEIIIToMCVyEEEII0WF0uuRcf6mqisvlbMb2CpWVRuz2KlwuyVQPpmBfa6PRhMEgMbsQQnREp1zgomkaxcX5VFSUNnvf3FwDqioZ6qEQ7GsdHh6FzRbv9/Q7IYQQ7cMpF7joQUtUVBwWi7VZf7iMRkV6W0IkWNda0zTs9ipKSwsAiIlJaPVzCCGECJ5TKnBRVZcnaImKsjV7f5PJIDUBQiSY19pisQJQWlpAdHScDBsJIUQHckrdsV0uF1Dzh0ucuvT3QHPynIQQQrS9ZgUuK1eu5He/+x2TJk0iIyODiy66iPfeew9N8+7Sf/fddznvvPMYNmwYF154IWvWrKl3rJKSEu677z7GjBnDyJEjueOOO8jOzm7Zq/GT5DUIeQ8IIUTH1KzA5eWXXyY8PJwFCxbw7LPPMmnSJO6//36efvppzzaffvop999/P9OnT2fx4sVkZGQwb948tm7d6nWsO++8k/Xr1/PAAw/w2GOPceDAAW666SacTvkGLIQQQgjfmpXj8uyzzxIfH+/5efz48RQWFvLSSy9x6623YjAYeOqpp5g5cyZ33nknAOPGjWPv3r08/fTTLF68GIAtW7bw7bffsmTJEiZOnAhA3759mTFjBp9//jkzZsxopZcnhBBCiM6kWT0utYMW3aBBgygtLaW8vJwjR45w8OBBpk+f7rXNjBkz2LBhA3a7HYB169Zhs9k444wzPNukpqYyaNAg1q1bF8jrEB3Mk0/+h0svvaCtmyGEEKKDafGsos2bN5OcnExUVBSbN28G3L0ntaWlpeFwODhy5AhpaWlkZmbSt2/fenkGqampZGZmtrRJmEy+4zFVDTyvQW+qooAmM6KDKpTX2mhUGny/nAqMRoPX/zuCrJxSNu3O5vyxvbFajD63yS2q5PONh7E7XF6Pp/eMZcKwbn6fy+5w8cn6g5SU21vUZnDnVVksJux2Z728QNG6OtO17pUczeTTUvzeXtU0PvvhMAN7x9G3m+/Zs5qmseqHw5zML292e6wWI+eN6UW8LQxom3tIiwKXTZs2sWLFCu69914AioqKALDZvC+W/rP+fHFxMdHR0fWOFxMTw44dO1rSJAwGhbi4SJ/PVVYayc01tOiPVXu9wWuahsPhwGKxtHVTPCorKwkLC/P5nD4DubHfQzCvtaoqGAwGYmIiGmzjqcRmC2/rJvjt+U92sn7bMXp2i2HK6F4+t3l3bSarfjhc7/Gvt2Rx9ujeRIab/TrX6k2H+ejbAy1qrxAtNSEjhW5dfP9dq2vjzyd488t9JMSE8eKfzsXk4z6qbxOo5IQoLpnc3+uxUN5DAg5cTpw4wV133cXYsWOZM2dOa7apRVRVo7jYdxRpt1dVl/rXml0jRFHcf0hdLrVd9Lj8858PsHv3Tm699Q6ee+5pDh06wF//+g8SE5N44YVn2LlzB0ajkfHjJzJ//u+Ji3MP882f/zu6dOnC/ff/HYDdu3dx443XcPbZU/jHP/4FwOHDB7nyyktZvPgVBg0awo4d21m69CV2795FWVkpKSm9+M1vruL882d62vPjj5u4445bePTRJ1ix4mM2bvyBjIyRPProE+Tm5vDvfz/Epk0biY62MXv2b9CL4uq/h5KSEp555kk2bFhPcXERsbFxDBs2nAcffDgo18/l0lBVlaKicioqXE3v0EkZjQZstnCKiytwuTpGjaKikkoAsk4WU1BQ5nObEznuytgj+3fxfOtc+cMhKqpc7DuYR++u9b84+bL/sLtQYVqPGEaktaxYoWJQsFrNVFU50NR2cBPpxDrLtV679Rh5xZX8/Es2YcYkv/b5aZ97dm5eUSVffn+QsYOT623zwRp30DI8LYF+PWKa1SarxciYgYmez15r3UNstnC/v6wGFLgUFxdz0003ERsby8KFCz0FvGJi3BegpKSExMREr+1rP2+z2Thx4kS94xYVFXm2aYmGgpKGKrFqmobd0fQFN5maH/A0xWI2BDw1Nzc3lyeeeIy5c28gObkrJpOJ22+/mXHjzuDBBx+msrKCxYufZcGC3/P88y8BMGLESD799GPPMbZu3YzFYmX79q2ex7Zs+ZHw8AjS0wcCcOLEcYYNG8HFF1+CxWLlp5+28cgjf0fTNKZPn+XVpkcf/SfTpk3noYcu9bwvFiz4PTk5J7nnnj8SFRXFa6+9Qnb2SYzGmm7+hQv/jx9++I5bbrmdrl27UViYz/r13wZ0XZojkCC2M3K51A5zHRzVn9WiUnuDbS4ucw/tjB2czJhB7hv3ln05HDheQnZ+OT38/PaaXVABwKj+XZg+rneL2m0yGYiLi6SgoKzDXOuOqiNda03TwFGBVlGCVlmCVlmKVlWKVllKl5iD7KpSOXYihRFpXfw63sHjJZ5/f/bDYU5LT/R6PiunlJ8P5KMocPW56XSJDaynpO51DeU9pNmBS2VlJTfffDMlJSW8/fbbXkM+qampAGRmZnr+rf9sNpvp2bOnZ7sNGzagaZrXH+0DBw6Qnp4e8IsJhKZpPPzaj/ySVRTS8+r6pcTwx6tGBRS8lJQU89hjTzFkyFAA5s37LQMHDuKhh/7tOV5qaj/mzLmcDRu+Zfz4iWRkjOK//32BEyeO07VrN7Zt28LMmRfy0Ufvc+jQQXr37sO2bVsYNmy4J7CYOvU8zzk1TWPEiJFkZ5/ko48+qBe4TJw4iVtvvcPz8/fff8fu3Tt58slnOe200QCMHHk6v/71TK8hxV27fmbq1PM9xzOZDJxzzrnNviai83NWd9eVVjga3EZ/LrrWkFBCTDgHjpeQW1Tp97lyityBS2KAN3dx6tKcVWhlhajlhWhlBWjlhWgVxagVRWjlRWgVxe7/KktB9V0GZAgwJBLKd+3E0eVyTP3PQGmi0veR7Jp1+H7JKuLA8WKvXJevNh8FYGT/xICDlrbWrMDF6XRy5513kpmZyeuvv05ysncXVM+ePenTpw+rVq1i6tSpnsdXrFjB+PHjPfkXkyZN4plnnmHDhg1MmDABcActO3fu5MYbb2zpa2q+DlqLLCYmxhO0VFZW8tNP27jttvmeCsEAPXv2IikpmV27djJ+/ESGDBmK2Wxm69YfOe+8GWzfvpW//vWf7NixjS1bNnsClwsv/JXnGMXFxfz3v8/zzTdryc3N8RzfV+/Y+PETvX7euXMHUVFRnqAFICoqitNPH8Pevbs9j6WnD2TlyuUkJHRh3LjxIQ9gRcfhrO45LSlvOHDRk2mjImpyvrpUJxM2K3ApdG/bJVbyoEQNTVXRygtRS3PRSnJRS3LRSvNRy/I9/8fezMRXcxhKWBRKWDSKNRIlLIrccgXXke0kUErl2iUYfvoc67jLMaUM9XmI8koHecXu9+zwtAS278/jy01HuemCwYA7oP9uh3u049zTfSf8aqoLrayg+jXlopbkoZXloZbmo5XloznthJ15bYNtCIVmBS4PPvgga9asYcGCBZSWlnoVlRs8eDAWi4Xbb7+de+65h169ejF27FhWrFjB9u3bee211zzbjhw5kokTJ3Lfffdx7733YrVaefzxxxkwYADTpk1rtRfnD0VR+ONVo/wcKmr99XNaMlQUF1cz5l5SUozL5eKpp/6Pp576v3rbZmefBMBqDWPgwMFs27aF9PQBlJaWMnTocEaMGMW2bVsYO3Y8J0+eICNjlGffhx56gB07tnPttTfSt28akZGRLFv2HqtXf1HvPHWnzOfl5RIbG9fkdnfd9Qdstud5++3XeOaZJ0lO7srVV1/Lr351afMuiuj09HH00grfM31UTaO0wv0NNsqrx8UdfOg39qZUOVyeIacuMR3zm6kInKY60YpzUItOoBZnoxZloxafRC3OQSvNBdWP3DiTBSUyDkNELEpELEp4DEqEDUN4jPvf4TaU8Gh3sGKqP7HClFfG33d8xzkRe5hl24maf4SKFY9hSErDMmQKptTRKMaa97je25JgC+OiiX3Zvj+PjbtOctk5acREWflm+zHsTpXeXcLpF1WG4+ABtOKT1a/N/Z9Wmg9a469NKy9s1rVsbc0KXNavXw/AI488Uu+5r776ipSUFGbNmkVFRQWLFy/mhRdeoG/fvixatIiRI0d6bf/EE0/w8MMP85e//AWn08nEiRP585//jMkU+nUfFUVpcFplbSaTAaOh/XTP1I53oqKiURSFa665jkmTzq63bUxMrOffGRmj+Prrr+jffwDp6QOIiIggI2MkTz75H7Zu/RGLxcKgQUMAqKqq4rvvvmXevLu49NLfeI7R0BTDukFYQkIXCgsL6m2Xn5/v9XNUVBTz5/+e+fN/z/79v/Dee2/xn/88QmpqGiNGjKy3vzh1OZrocamocqJWvz99BS651cM/TdF7ZsKtRiLDTqn1aE8pmtOOWngctSALNf+o+9+Fx1GLcxr/A64YUaLiMUR3QYlKwBCV4P45Mt7zf8xhLVpeJDE2HM1g4ovywUz7zW+I3P8Fjp+/RM3eT2X2fpQNb2IeeBbGXsPRinPQdu3mxqgD9LKUEfftCu7popFTYSZr1S4s3WNJ2r6bP8cU0EUto/y9Rr6EG4woUV0wRHep/7psSRhs/iUKB0uzPo2rV6/2a7vZs2cze/bsRreJjo7moYce4qGHHmpOE0QDwsPDGTp0GIcOHWDgwFsb3XbEiJEsXfoSq1d/QUbGadWPjSInJ5tPP/2YQYOGeIb1HA4HqqpiNtf8ASgvL+Pbb/0rFDho0BBKS0vZvPl/nuGi0tJSNm3aWG/avC4trR933vl7PvnkQw4ePCCBi/BS0+PiO3AprQ5owixGzLWm23fRe1z8HCrKLayo3i9c1rbqJNTyQtTcw7jyDqHmHnIHKsUnGy4YZbJiiOmKISYJgy0Zgy0JxZaEwZaIEhHXZL5JS5mMBpLjIziWW8axUoVh46/AMmI6jt3rcOxag1ZWgH3rcti6HIAeQA8LoIJaUEBPoKcVyD+IMx/SazfXHI4hJtn9ny0JQ0yy+7VFJ6JExKAo7bP0B7RCATrRftx663zmz/8df/nLH5kyZRrR0dHk5GTzv//9wIwZFzBq1OkADB8+AqPRyNatP/Kb31wNQFxcHH369GXr1h+ZM+d6zzGjoqIYNGgwr732MrGxsRiNJl577WUiI6MoLMz32Y7axo2bQHr6QP72tz9zyy23Ex0dzdKlLxMZ6T2r43e/u54zzzyH1NQ0jEYDn322ArPZLEGLqMdZHbhU2l04nKpXcAJQUh3QRNWp1ZJQneNSVumkospJuLXx25/e46IHPKJjcVWW4TiyA/vxX1BzDuDKOdDwEIc1EmN8Coa4Hhhiu2OI7YYhthtKZFybB63dE9yBy/HcMoalJmCIiMU66kIsGTNxHvwRx641qAXHMMR0ZfNJE/tKIhg3fgTpKbE4y4v4+MvtGB1lhJtUjtuj6DswnbPPOs09VNVBA3IJXDqRYcNG8MwzL7JkyfM8/PCDOBwOEhOTOf300aSk9PRsFxERSf/+A9i7dzfDh2d4Hs/IGMXBgwe88lsA/vrXf/Lvfz/EP//5ADZbDJde+hsqKsp5663XaIqiKDzyyH947LGH+fe/HyY6OppLL72c/Px8vvnma6+2f/bZpxw7dgyDQSEtrT//+tfj9OnTt6FDi1OUs1ZZg9IKB3HRVq/n9R6X6AjvwCXcaiIyzERZpZO8okpSkqIaPU9Oocwo6ig0TUMrycV1Yq/7v5P7KCg45mNLBUNsVwwJvTF26YUhoReG+JR2/Ue8W0IkkMOxPO+aRYrBiDl1NOZUd0+2S1VZ+p91OF0qswaMxBQXgQkIz+3OsnXuivQGReFXZ4zHENGxg3EJXDqoP/3pAZ+PDxw4mH//+8km93/xxVfrPXbPPX/knnv+WO/xlJSePPnks/Uev+GGmz3/HjXqdL79dpPPcyUlJfPoo0/Ue3z+/N97/n3rrfO59db5np+DkQgtOgdnrSJXvgKXkuqk3ajw+smOXWLCKassIbe46cBF73GRwKV9UktycWXtxHlsF65ju3z2phhsSRgS+2JMSsWQmIoxoReK2Vr/YO1Yty4RABzLa3yW0om8cpwulTCL0Wua81kZ3flk/UGcLpXTByZ6SvV3ZBK4CCE6FK8eFx9rCJU2MFQE7gTdQydL/Mpzqclx6fg3+s5Ac1ThOrYT5+HtOLN2ohWf9N5AMWJI7IOxazqWHgPoMmA4xXZTh/8C1D3BPax+PLesXu2z2g5XzyhKSYrCUGsbW4SF88f2ZM2PWcxoYRHF9kICFyFEh6FpmldZ8RIfCboNDRWB/wm6mqZ5is911CJdnYFakovz0Bach7fhOr4bXLUKtSkGDIl9MfUYjLH7IIzJaSgmd2+KyWTAGBkJdt9LQnQkXeMjUHDnZhWXO4iJ9L0enT4VuqePnsRfT0rj15PSgtnMkJLARQjRYaiaRu35H75mFunBjK/AJcHm35RodwKveyqs9LiEllp4AseBTTgPbELNPej1nBKVgKnXCEw9h2HsNhDF0vmDSovZSGJsONmFFRzLLWsycOnVxBBoZyCBixCiw3A6vaetlvqo5aI/5muoqIufRej0wMYWacFqbrrGk2gZtTQPxy/f4/xlA2r+0VrPKBi79sfUOwNjrxEYYru32yTaYOqWEEF2YQXH88oY1Lt+QU+AIyfdaxT1TPJvAdGOTAIXIUSHoa9TpPM5VOTJcan/zbSmCF0TgUt1qf9E6W0JGs1ejiPzfzj3bcB1fA/ofWmKEWOPQZj6no6p90gMES1feLej694lkm378zie6ztBt6i0iuJyB4oCPRL9W0C0I5PARQjRYTjrrPBe4iM5V3+ssRyXknIHVXZXgxWzZXHF4NA0DTUnE8eur3Hs/wGcNb8/Y7cBmPpPwNznNJSwzj/c0RzdqhN0606J1unDRF3jI06JHkIJXIQQHUbtxFzwnePS2KyiiDAz4VYjFVUu8oor6d7F97fTXFlcsVVpjkoce9fj2P01at4Rz+OG2O6Y0idg7jceQ1RCI0c4tenv04YCl8ONJOZ2RhK4CCE6DEfdwKVOjotLVSmrrF5g0UePC0CCLZyjOaXkFjUcuHhmFMniii2iluZh3/Eljt1fg706IdpoxpQ6BvOgszEm9zslc1aaq1uCu5ZLUamd8koHEWHe7+3GZhR1RhK4CCE6jHpDRXV6XMqqV4VWoMGFEbvEhHE0p7TRBF3JcWkZV85B7NtX4sz8H2juYFOJScYyeArm/hNkKKiZwq0m4qKtFJRUcSyvnH49vPN+agKXzp+YCxK4CCE6EF9DRbWLcumBTESYCWMDC+A1tUq0qmk16xRJjkuzuE7+QtWPH+M6st3zmLH7ICzDzsPYa3i7XrivveueEOEOXHLLvAIXu8PF8eohpFOlx0XeRSJolix5np9+2lbv8YkTT+eNN5YG7bzr1n3NxImnc/y4r7VKREem97jo+SsOp4rdUWsJgOrE3KgI37UuoOkidEWldpwuFYOiEG/rWOXh24rzxD7KVzxG+Uf/cActioKp33gifv0gEbPuxdQ7Q4KWFtITdI/XyXPJyi1D09zJ6LFRDb/vOxPpcRFB89JLiwkPj2DYsBFt3RTRSejrFEWGmai0u3C6VEoq7FirC5HpibnRPhJzdXoRuoYCF31xxXibtcFeG+Hmys+iauM7uA5Xf0FRDJj6n4F15CwMMclt27hOxpOgW2dKdO38llMlX0gCFyFEh6EHLiaTgegIMwUlVZRWODxJtCWNzCjS6TOFGqrlkitToZuklhVg37QMx95vQNNAMWBOn4hl5CwMtqS2bl6npCfo1u1xOXLy1ErMBQlcOqzMzP0888yT7Nz5M1VVlSQlJTNr1kVcddVc/vnPB9i9eyd33PF7Fi16nCNHjjB48BD+9KcHiIyM5N//fpgffthAbGwsN998G1OmTPM69ocfvs/bb7/OiRPHSUjowqxZFzFnzvUYan373L//F55++gm2b9+K0Whk9OixzJt3N127dgXcw0EAzzzzJM88416t+qmnnmPUKPfjmqayZMnzfPjh+6iqizPOmMRdd/2B8PCaPxbZ2Sd57rlF/PDDd1RUVDJo0GBuv/1uBg4c5NnG6XTy9NNPsmrVp6iqi7PPnuI5h+h89KEik8FAVHh14FJrZpGnam4DM4qgpselqMyOw+nCbPKue+GZCi2JufVoTjv2rZ9i37YSXO5hOVOf07COuRRDbLc2bl3npve45BVVemoQlVU62HkoH4Bep0hiLkjgAriLItUuhNTwdga01l5p1GQJqHvv3nvvJj4+ngUL7icqKoqjR4+Qk5PteT4/P49Fi55gzpzrMZlMPPHEY/ztb3/Gag0jI2MUF154MR9//CF/+9v9DBkyjK5d3Ted9957iyeeeIxLL72cCRPO5KeftvHSS4spLS1l3rw7ATh58gS33XYTPXqkcP/9f8dur+KFF57l9tt/yyuvvElERCTPPfcSt9xyHZdeejlTp54PQN++fT3te//9dxgxYiR/+tMDHDlymGeeeZK4uHh+97vbASguLubWW28kPDycO+/8f0RFRfHee+8wf/4tvPXWMuLi4gF47rlFLFv2LjfccDPp6QP58svPeO65RQH9KkT7pyfnmowKFrP79lV7ZpE/Q0VR4WasZiNVDhd5xVV0jY/wel4WV/TNeWgrld+9jlaSA4AhuR9hYy/H2LV/G7fs1BAdYSEq3ExphYMT+e7hoqeX/URuUSUWs4GBDSwF0Bmd8oGLpmmUf/xP1JO/tMn5jcn9Cb/wvmYFL4WFhRw/nsX8+b9n4sRJAPV6GYqLi1m48AVSU90rgubm5vD44//mqqvmcu21NwIwcOAQ1q1bw7p1X3PZZVfgcrl4+eUXmTJlGnfe+f8AGDNmHE6nk7feeo1rrrmWmJhY3nnnDVwuJ48/vgibzZ3dnp4+kKuvns2KFZ9w6aW/YejQYQAkJXX1/Lu2hIQu/PWv/wBg3LgJ7N27m6+//soTuLz99uuUlpawePErniDltNPGcMUVv+bNN5dy663zKS4uYtmyd7n66mu55prrABg7djzz5v3WK4gTnYdex8VoNHgq49bucSnxo8dFURS6xISRlVtGXlFlvcBFpkJ7U0tyqdrwBs6DPwKgRMZjHf8bTH1HnzI5Fe1F94QI9h4tYvl3B9m2Pw+nS6VLTBi3/WoYcdGnTiK5ZJ4BCh3rwxcTE0PXrt14/vlFrFy5nOzsk/W26dIl0RO0APTs2RuA008f43ksOjqa2Ng4z/6HDh2ksLCQyZOneh1r8uRzcTgc7Nz5MwDbtm1l1KjTPUELQO/efejXrz/bt9efReTL6NFjvX7u06evV7Dxww/fM3Lk6URH23A6nTidTgwGAxkZo9i1ayfgHq6qqqpi0qSzvY511lmT/WqD6Hhc1UNFZqPiyWPx3ePS+OyKxqZE50qPC+AezrVv/4yyd+9zBy2KEcuIGURe9hDm1DEStLQBfbho894cnC6VEWkJ/PW60fTueuoME4H0uKAoCuEX3ufXUJHJZMDZDoaKFEXh//5vES+88Az/93//oqKiggEDBnH77XeRkTEKgKgo70Qtk8n9q46O9n6Dm81m7PYqAEpK3KuL6j0cuvj4+Orniz3/798/vV674uISKC4u8us1REX5akfN76CwsJAdO37i7LPH1du3R48UAPLychttr+h8nLV6XPTApbTWekUlnunQDfe4QMOLLTpdKvkl7s/DqdzjohZnU/n1i7hO7AXc6whZz5iDMb5HG7fs1NYj0X1fVxT41ZmpzBjfG8MpGECe8oELuAMBzE13sykmA4rSyoFLgHr16s0//vEvnE4nP/20jRdeeJp7772LZctWBnxMm80GQEFBgdfj+fnu5K/oaJtnu4KC/Hr7FxTkeXp2Wspmi2Hs2J7cdNMt9Z4zm93fphMSulSfN5/ExJqZDHp7RefjVKuTc40GoqtrtTQ3xwWgiz4luk713LziSjQNLCYDtshToyZGbZqm4di1hqrv3wZnFZjDsI77DeaBZ0kPSzswfkhX8oorGZGWwIBep05OS10yVNTBmUwmRo48jauuupaysjJyc3MCPlavXr2JjY1jzZovvR5fvfoLzGYzgwcPAWD48Aw2b/4fxcXFnm0OHz7I/v2/MHx4Tc0Wk8nk6c1prtGjx3DwYCa9e/dl4MDBXv+lpfUDIC2tH1arlXXrvvbad+3a1QGdU7R/eo+nyaj4znGpaDrHBRrucalZXDH8lPtDrZYXUrHiMaq+fRWcVRi7DSTy0r9jGXT2KXct2quIMBOXndPvlA5aQHpcOqRfftnHokWPM2XKNHr0SKG0tJSlS1+iW7funmGUQBiNRq699gaeeOIx4uLiGT/+DH7++SfeeONVZs++gpiYWAAuu+xKPv30E+6+ex5z5lyP3V7F4sXPkpzclRkzLvAcr3fvvnz77TpGjBhJeHg4vXr1JiLC96J2dV155dV89tlK5s37LbNn/4bk5K4UFhawc+fPdOnShcsvvwqbLYaLL76E1157GavV6plVlJV1NOBrINo3p6oHLrWGiqqDFYfTRZXdBTTd45LQQPXcmsUVT61hImfWTipXP4dWUQxGC9axszEPmSLVbkW7JIFLB5SQkEBCQgJLl75Ebm4OkZFRjBiRwV/+8neMRmPTB2jEpZf+BpPJxFtvvcGyZe+SkNCF6667iTlzrvdsk5zclUWLXuDpp5/gb3/7MwaDkdGjx3D77Xd7BSZ3330vTz75GPfccwdVVVVedVyaEhMTy/PPv8Tixc/y7LMLKS4uIi4unsGDh3ol495yy+24XC5ef/1VNE1l0qRzuOWWefz9739p0XUQ7ZOnjouP5NzS6gUWDYpCuLXxW5tesK6wpAqnS8VkdP+BrplRdGok5mqqin3Lx9g3fwRoGOJTCJt6K8bY7m3dNCEapGiapjW9Wcfhcqnk55f5fM7hsJOXd5yEhG6ePInmCEpyrvAp2Ne6pe+FzsJkMhAXF0lBQVmHeG9/+E0mH68/yDmjejBrfB9+//R6DIrC4j+czZHsUh546X/YIi08cfvERo+jaRq3/GctDqfKIzePIynOPSX6uY92sHFXNpdP7sd5Y3q1atvb27VWy4uoXP0crmO7ADAPnIR1wtUopo7/eWhv17oza61rHR8fidHoXw+f9LgIIToMvY6L2WggKtx9+1I1jYoqp9+JueBOyE+whXEiv5y8okqS4iLQNI2TBfpQUefucXHlHqLisyfRyvLBZCXszLmY+09o62YJ4RcJXIQQHYZex8VoVDCbjFgtRqrsLkoqHJ7ApbF1imrrEuMOXH45Vkzm8WK+2X6c7OrAJSmu8wYujgObqVzzPDjtGGK6EnbeHTI0JDoUCVyEEB2GZ5HF6nWzosPNVNldlJY7/KqaW5ueoLtsXabnMavFyFkjupOS6F8SeUeiaRr2rcux/+99AIwpQwmf8jsUa+d7raJzk8BFCNFh1E7OBXfvSm5RpVePiz9DReC9mm7/lBjOHN6d0QOTsFpaluDeHmkuB5Vr/4vzlw0AmIdMxTr+ChRD53utovM7JQOXTpaPLAIg74GOydPjYnL3uETVquXiz8rQtU0a0R1bhIUeiZF0S+i8vQ6ao5KKzxfiyvoZFAPWM67GMliWxRAdV7MDl0OHDrFkyRK2bdvGvn37SE1NZfny5Z7njx49ypQpU3zua7FY+OmnnxrdbsSIEbzzzjvNbZZf9KnCdnsVFsupsyCVqE8vjGc0npKxe7tRaXdiNRv9LnDma6gI3LVcSiqqy/03sU6RzmQ0cPrApKY37MC0ylLKVz2Omr0fTFbCp92OKWVoWzdLiBZp9l173759rF27lhEjRqCqar1vrklJSbz99ttej2maxo033si4cfXXnbn77rsZO7Zmwb3IyOB98zEYjISHR1Fa6i5pb7FYm1URUlUVT3KgCK5gXWtN07DbqygtLSA8PAqDQQpstZVDJ0r4x6ubOG9MLy49O63pHahJzq0ZKtLL/tubPVTU2anlhVR8+hhqwVGwRhIx/W6MSf5dZyHas2YHLpMnT2bqVPfqwQsWLGDHjh1ez1ssFjIyMrwe++GHHygtLWXWrFn1jte7d+962weTzeZegE8PXprDYDCgqlITIBSCfa3Dw6M87wXRNg6dLMGlamQe829hTvBeZBFqhoVKaiXnRvs5VNSZqcXZlH/6b7SSHJSIWMJn3IMxPvCq2kK0J80OXAL5hrp8+XKioqKYPLntx1UVRSEmJoHo6DhcLqff+xmNCjExERQVlUuvS5AF+1objSbpaWkH9PL89mYUrXLWquMCeK1XVOrnOkWdnVqcTfknD6OVFaDYkoiY8f8w2BLbullCtJqgD/A7HA4+//xzzj33XKzW+nklDzzwAHfddRexsbFMmTKFe+65h9jY2BadU0/ca5yB5rx8o9FAWFgYdruGyyW9LsEk1zp09J4LfytWtia9mJzTpfr5mQVX9erQFosRk8lATJT7nlJaWZOcGxtl9ft4oRSKa62W5FL26aNoZQUY4roTfdECDBGxQTtfe9WW7+tTTVtc66AHLuvWraOwsLDeMJHFYuGKK65g4sSJ2Gw2tm3bxnPPPceOHTt49913MZsD+9ZkMCjExQUvT8Zm67yFqdobudah0xbXWqm+0blUzf/PbHVOWowtnLi4SLonRQOQX1zlCYR6do8lrIm1itpSsK61sziPY8sfRS3JxRzfjW5X/w1T9Km9irDcQ0InlNc66J/uTz75hC5dujB+/Hivx5OSknjggQc8P48ZM4b+/ftz880388UXXzBjxoyAzqeqGsXF5S1psk9GowGbLZzi4grpBQgyudah05bXuqjEvaBhRZWTggLf64vVVWl3D+9WVdrd+7jcw035xe5jmU0GyssqqSj3P+k+VIJ5rdXyIko+fAi18AQGWyIRs+6lxGkBP69rZyP3kNBprWtts4W3j7WKysrKWLNmDbNnz/Zr1eKzzjqLiIgIfv7554ADFyCoi2q5XKos2hUicq1Dpy2udWWVOwixO/w/t6N6OwX35zzc4n0Liwo3V+dFtd88tNa+1lplKeWf/Au18DhKZDzhM/+AGhaLKp8duYeEUCivdVAHpb744gsqKyu54IILgnkaIUQHVOVw3+QczUrO1adDu29dkeHegcupNhVac9qp+OxJ1IKjKBGxRMy6F0O0JOKKzi2ogcvy5cvp1asXI0aM8Gv7NWvWUF5ezrBhw4LZLCFEO1Azq8jldyVjl2c6tHsoyGgwEBlWE7ycSjOKNE2l8uvFuE7uA0s44TP+H4aY5LZulhBB1+yhooqKCtauXQtAVlYWpaWlrFq1CnDnqcTHu2tj5Ofns2HDBm666Safx3nkkUdQFIWMjAxsNhvbt2/n+eefZ+jQoZ46MUKIzqvK4Q5cNM2doKsXlWtM3cq54B4eKqt0ev59qqj64V2cmf8Dg5HwaXdgjO/R1k0SIiSaHbjk5eUxf/58r8f0n1999VVPFdyVK1fidDobHCZKS0vjzTff5J133qGyspLk5GQuvfRS7rjjDkym9jsjQAjROuzVgYv736pn+KcxnqGiWtOdoyLMnCyoACDaz3L/HZ39569wbF8JQNhZN2DqPqiNWyRE6DQ7QkhJSWHPnj1NbnfVVVdx1VVXNfj87NmzmT17dnNPL4ToJKpqBS4Opwt/bkeeHpdavTO1g5VTYajIeWgLVd+9BoDl9F9j7j+hjVskRGhJdR4hRJuoHbj4Wz3X0+NSZ6jI1787I1dBFhVfPQeahnnAJCwjZeKDOPVI4CKEaBN6ci74F7hoWk0l5do9LrV7WTrzOkWavYKKzxeCswpjt4FYz5zTrEVihegsJHARQrQJfTo06ENFjXOpmqc6S+0cl9pToDvrdGhN06j8+kW0ohMokfGETb0VxSC5gOLUJIGLECLkNE2rl5zblNoLbnoNFdXqZYmK6JzJufZtK3Ae3AwGE+Hn3oYh3NbWTRKizUjgIoQIObtT9apt608ROqdas42xoeTcTtjj4szaif1/7wFgPeNqjElpbdwiIdqWBC5CiJCrnZgL7iJ0TXHW6nExGnznuHS2wEUtzaPyq2erk3HPxDzwrLZukhBtTgIXIUTI2e3egYpfPS5OPTHX4JWUGh9tBdyJuWZT57mlaapK5ern0SpLMHTpg/WMayQZVwhCsDq0EELUVa/HxY8cF32oqG6F3XhbGDddMJjYKGvrNbAdsG9bgevEXjCHET71VhRT58zfEaK5JHARQoRcVZ1AxZ9ZRXUXWKxt/JCurdOwdsKVcwD7pmUAhJ1xNQZbUhu3SIj2o/P0qwohOoz6OS7+zCryXmCxs9IcVVSsfh40F6bU0Zj6n9HWTRKiXZHARQgRcoEELo7qwMXsx5pGHVnVhjer67XEETZxruS1CFFH574DCCHaJbujbnKuHwXoqoeKjJ04cHEc/BHH7q8BhbCzb0IJi2rrJgnR7nTeO4AQot2qsgeQnOuj3H9nolaWULXuJQDMw8/D1GNwG7dIiPZJAhchRMjVHSryazq0jwUWO5OqDW+6pz7HpWAdfUlbN0eIdqtz3gGEEO1aYAXoqntcTJ2vx8V5dAfOfd8BCmFnXYdi7FyF9IRoTRK4CCFCrv506GYMFXWyHhfNUUXlN68AYB46VUr6C9GEznUHEEJ0CHpybmSYu5SUP4GLy1PHpXP1uFRtXoZWkoMSGY/19F+3dXOEaPckcBFChJw+VKSvLeTPdOia5NzOc9ty5R7E8dNnAIRNnINiCW/jFgnR/nWeO4AQosPwBC7VCyQ6HM3IcekkgYumuqhc+xJoGqbUMZh6Z7R1k4ToEDrHHUAI0aHo06Gjw93r7/jX46LXcekcQ0WOHV+i5h0CSwTWCVe2dXOE6DAkcBFChJy9zlCRX8m5aufpcVEriqna/CEA1rGXYYiIbdP2CNGRdPw7gBCiw9FnFelDRf5Nh254kcWOxv6/D8BRgSGhN+aBk9q6OUJ0KB3/DiCE6HD0HJfo5iTnOjtH5Vxn7mEce9YCYJ1wJYoit2EhmkM+MUKIkNNzXDxDRf6U/O8EQ0WaplGx/vXqhNzRmLoNaOsmCdHhdNw7gBCiw6o7q8ifHhdXJ0jOLd+7EWfWLjCasI69rK2bI0SHJIGLECLkaoaK3LOKnC4VVdMa3UefDm3uoD0umstB3levAmAZdj6G6MQ2bpEQHVPHvAMIITosTdNqApeImjV5mppZpAcuxg4auFRt/xxnwQmUiBgsI2e1dXOE6LA65h1ACNFhOV0qeudKZHhzApeOW/JfrSimYtNHAISPuwzFHNbGLRKi45LARQgRUrUXWAy3GjEa3IGIvYnquR15kUX7thXgqMSS3BfLgDPaujlCdGgd7w4ghOjQ9BlFJqOC0WDAYnbfhprqcfEssmjqWLcttbwQx89fARB/tkx/FqKl5BMkhAgpPb/FajYCNcm2Tc0scnh6XDrWUJF9yyfgcmDs2p/wtJFt3RwhOjxTc3c4dOgQS5YsYdu2bezbt4/U1FSWL1/utc0111zDxo0b6+27YsUK0tLSPD+XlJTw8MMP8+WXX+JwODjzzDP585//TFJSUgAvRQjREeiBi0UPXExGwNFk9VxXB1xkUS3JxbHrawDCx16ConSsoEuI9qjZgcu+fftYu3YtI0aMQFVVtAamMI4aNYp7773X67GUlBSvn++8805++eUXHnjgAaxWK0888QQ33XQT77//PiZTs5smhOgA7HV6XDxDRU0UoeuIiyzat3wMqgtj90GYewxu6+YI0Sk0OzqYPHkyU6dOBWDBggXs2LHD53Y2m42MjIwGj7Nlyxa+/fZblixZwsSJEwHo27cvM2bM4PPPP2fGjBnNbZoQogOoN1Rk8m+oSK+c21HquKhFJ3Hs+RYA6+m/buPWCNF5NPsOYGiljP5169Zhs9k444yaDPvU1FQGDRrEunXrWuUcQoj2R59VZK3uabGY3AGMo4mhIqdT73HpGIFL1eYPQVMx9hyOsWv/tm6OEJ1G0MZjNm7cSEZGBi6XixEjRjB//nxGjx7teT4zM5O+ffvWG/NNTU0lMzOzRecOxqwD/WbZUW6aHZlc69Bpi2utT2sOs5owmQyeXBeXqjX62XVV97hYLcZ2P7PIlZ+F85fvAYgYewkmk0He1yEk1zp02uJaByVwGT16NBdddBF9+vQhOzubJUuWcN1117F06VJGjnRn1RcXFxMdHV1v35iYmAaHn/xhMCjExUUGvH9TbLbwoB1beJNrHTqhvNbG6h6WqEgLcXGRRFZXzzVZzI1+dvVsurjYiKB+xlvDyTWfABoRA8aSOGCo13Pyvg4dudahE8prHZTA5Y477vD6+eyzz2bWrFk888wzLF68OBin9FBVjeLi8lY/rtFowGYLp7i4wjO7QQSHXOvQaYtrXVBUAYCiQUFBGUp1gn9hcTkFBWUN7qfXf6kor2p0u7bmKjpJ2e4NABhHXOBpq7yvQ0eudei01rW22cL97rUJydSdiIgIzjrrLD777DPPYzabjRMnTtTbtqioiJiYmBadz+nHSrOBcrnUoB5f1JBrHTqhvNYVVU4ALCYDTqfqmd5cVeVqtA16HReF4H7GW6ryxxWgaRh7DofYlHptlfd16Mi1Dp1QXus2GwBMTU3lwIED9aZTHzhwgNTU1DZqlRAi2OrOKrKYmlc5tz3nLajlRTj2fgOAZYTMjBQiGEJyBygvL+frr79m2LBhnscmTZpEUVERGzZs8Dx24MABdu7cyaRJk0LRLCFEG9BnFen1W8zVOS9NTof2FKBrv3VcHD9/CS4nhqRUjN0GtHVzhOiUmj1UVFFRwdq1awHIysqitLSUVatWATBmzBgyMzN58cUXOffcc+nRowfZ2dm89NJL5OTk8OSTT3qOM3LkSCZOnMh9993Hvffei9Vq5fHHH2fAgAFMmzatlV6eEKK90XNVrBbvAnRNVc7VC9C11zoumr0Ce/WaRJYRM6RKrhBB0uzAJS8vj/nz53s9pv/86quv0rVrVxwOB48//jiFhYWEh4czcuRIHnzwQYYPH+613xNPPMHDDz/MX/7yF5xOJxMnTuTPf/6zVM0VohOrWznX7MdQkaZpnh6X9jpU5Ni9FuzlKDFdMfUe1dbNEaLTanaEkJKSwp49exrdZsmSJX4dKzo6moceeoiHHnqouc0QQnRQ9XNcqoeKGin571JrcuHa41CR5nJi/+lzACwjpqO0UqFOIUR98ukSQoRUZYM9Lg0PFemJuQCmdhgUOPd/j1aWjxIeg7n/hLZujhCdWvu7AwghOjV73RwXP9Yq0tcpAjCZ2lePi6ap2LetAMA8bBqK0dzGLRKic5PARQgRUvUWWTQ3neOi14dQAEM7S3p1HdmBWnAMzOFYBp/T1s0RotOTwEUIEVIN5rg0MlTkrFXDpb3N1rHvdM8kMg84E8US0catEaLzk8BFCBFSdeu4eArQNZKcqw8VtbfEXLU4B9fh7QBYhkxu49YIcWqQwEUIEVINTYduNMelusfF1M6mQtt3rgY0jClDMcR0bevmCHFKaF93ASFEp+Z0qZ6pzTUF6Nz/b2xWkZ7j0p56XDSnHceedQBYBk9p49YIceqQwEUIETJ6fgs0s8fFM1TUfm5Zzv0/QFUZSlQCxl4j2ro5Qpwy2s9dQAjR6enl/o0GxROE+BO4uNrhUJF7mAjMg8+RgnNChJB82oQQIaP3uOjDQ1Azq6jR5Nx2tsCiKzsTNecAGEyYB8iisEKEkgQuQoiQ0cv6W801tx69x0WttR5RXe1tnSJ9CrQpdTSGcFsbt0aIU0v7uAsIIU4JdWu4QM10aGi4CF3NrKK273FRK0vc+S2AZYgk5QoRahK4CCFCxlfgYq4VuDSU56L3uJjbQY+LY/c34HJi6NIbQ1JaWzdHiFNO298FhBCnDD0512KpCVwURalZaNHhe0q0q1bl3LakaRqO3V8D7inQ7a2KrxCnAglchBAh46vHBZpeaNGhJ+ca2jZQcJ3Yi1acDeYwTGlj27QtQpyqJHARQoRM3aq5Ok+PSwOBi8vVPuq4OPd+C4A5dTSK2dqmbRHiVCWBixAiZKp8zCqCphda9CTnmtrulqU5qnBk/s/djgFntlk7hDjVSeAihAiZhoaKzObGh4o8lXPbcKjIeWATOCpRbEkYk/u3WTuEONVJ4CKECBlfBeig6RWi9bWK2jI516EPE6VPlKRcIdqQBC5CiJBpsMdFr57bYAG6tq3jopbk4Dq2C1Awp5/RJm0QQrhJ4CKECBl79XRoq6WBWUUNTIdu60UWHXu/A8DYYxCGqIQ2aYMQwk0CFyFEyDTc49LUrKK2W2RR01SvYSIhRNuSwEUIETKVDdVxMeuzipqo49IGQ0Wu43vRSnLctVv6nhby8wshvEngIoQImYaGimp6XBqqnNt2ybme3pa0MSgmqd0iRFuTwEUIETIN13HRc1waT84N9VpFmqMSp167JV1qtwjRHkjgIoQImYZL/lfPKmpikUVjiIeKnAc2g7MKxZaMMblfSM8thPBNAhchRIvtzypi75HCJrdrqI6L2bNWUROVc0Pc4+LI3AiAud84qd0iRDshgYsQokVcqsp/3t7K/729tcHpzLqG1iqyNFU5tw0WWdSqynAd3eE+ryyoKES7IYGLEKJF7A6VSrsLu1P1zBpqSJMF6JpaZDGEaxU5D/4IqgtDfArGuO4hO68QonESuAghWsSlap5/OxsIPNzbqZ4hn2YXoGuDoSLH/h/c50wdE7JzCiGaJoGLEKJFaveSOBso2Q9QZa95ru6soqYK0IV6qEitLMGVtdPdtjQJXIRoT0zN3eHQoUMsWbKEbdu2sW/fPlJTU1m+fLnn+dLSUl566SXWrl3LwYMHsVgsDB8+nLvuuosBAwZ4tjt69ChTpkypd/wRI0bwzjvvBPhyhBCh5qoVrDhcWoPb6cNEilK/56QmObfx6dChquPiPLAZNBVDQm8MMV1Dck4hhH+aHbjs27ePtWvXMmLECFRVRdO8b1THjh3j7bff5pJLLuHOO++kqqqK//73v1x++eW8//77pKWleW1/9913M3ZsTeJbZGRkgC9FCNEWnH4OFdVOzK07Q6dmOnTjaxWZQzQd2lk9m8iUNjok5xNC+K/ZgcvkyZOZOnUqAAsWLGDHjh1ez6ekpPDFF18QHh7ueWzcuHFMnjyZN954g/vvv99r+969e5ORkRFA04UQ7YHT36GiBhJzAcxNzioKXY+LWlFcvRI0mCW/RYh2p9mBi8HQ+I0jIiKi3mORkZH06tWL7Ozs5p5OCNHO6b0hEHjgoifnOhqqnOsM3erQzgObQNMwJPbFYEsK+vmEEM3T7MAlEMXFxezbt48JEybUe+6BBx7grrvuIjY2lilTpnDPPfcQGxvbovMFY8qk/k2vLdZKOdXItQ6d1rjWtUeLVa3hz1/tGUV1twm3um9FDpfqc39XdXDka9/WVlFd4t/ab2yrnkve16Ej1zp02uJahyRw+fe//42iKFxxxRWexywWC1dccQUTJ07EZrOxbds2nnvuOXbs2MG7776L2WwO6FwGg0JcXPDyZGy28KY3Eq1CrnXotORah+dVeP4dFm5p8PNnthYBEBlurrdNafWMI4dT9bm/3pGTEB8Z1M+3s6SAgmO7Aehy2lmYY1r/XPK+Dh251qETymsd9MDl/fff55133uGRRx6ha9ea7PykpCQeeOABz89jxoyhf//+3HzzzXzxxRfMmDEjoPOpqkZxcXlLm12P0WjAZgunuLjCaxaFaH1yrUOnNa51fmHN562gqJyCgjKf2+UVuLczGpR621SUVwHu4SRf++tJu2WllRRYgvfNrnL714CGMTmNUjUSGngtgZD3dejItQ6d1rrWNlu43702QQ1c1q5dy1/+8hduvfVWfvWrXzW5/VlnnUVERAQ///xzwIELND6zoaVcLjWoxxc15FqHTkuutd3u8vp3Q8epqHQC7nyWutsYqmcZOZwqDoer3qwjPXdGIbifb/u+6qJzfccE7Tzyvg4dudahE8prHbSvLlu3bmX+/PlcfPHFzJ8/P1inEUK0MadXHZeWJedC/SJ0mqaFZFaRq+AYrpP7QFEwpco0aCHaq6DcBX755Rduvvlmxo0bx4MPPuj3fmvWrKG8vJxhw4YFo1lCiCCoHbg4/ShAV7fcP9QUoIP6U6JrLykQzDoujl1rADD1ysAQFR+08wghWqbZQ0UVFRWsXbsWgKysLEpLS1m1ahXgzlPRNI0bbrgBq9XK3Llzveq8REVF0a9fPwAeeeQRFEUhIyMDm83G9u3bef755xk6dKinTowQov2rHaw01lXcWI+LyWjAoCiomlavx8VV6/jB6nHRHFU49n4LgHnw5KCcQwjROpoduOTl5dUb+tF/fvXVVwE4ceIEANdee63XdmPGjGHp0qUApKWl8eabb/LOO+9QWVlJcnIyl156KXfccQcmU0gmOwkhWoF3j0sjlXOrZw5ZfAQu4C5CV2V3Ya9TPbf28JMpSD0ujv3fg70CxZaEMWVIUM4hhGgdzY4QUlJS2LNnT6PbNPU8wOzZs5k9e3ZzTy+EaGf8zXGpdLiTc+susKizmNyBS/0el+rEXAWMTRTADISmaTh2rna3YdDZKIrU/hCiPZNPqBCiRbyGihpNzq0uItdAj4ulgRWi9eMHq2qumnMANfcQGE2YBpwZlHMIIVqPBC5CiBbxGipyNpyca28kxwXAXL3Qor6d55iqXu4/OMNE9p1fuY+fOgZDWHRQziGEaD0SuAghWsTv6dD2hmcVQSM9LtU/B2WYqLIU5373StAWScoVokOQwEUI0SL+DxW5A5fGknOh/nRo/fjmIKxR5Nj7DbgcGBJ6YUhKa/XjCyFanwQuQogW8R4qCmw6NIBFHypy+h4qMhpad6hI01TsO78G3FOg61brFUK0TxK4CCFaxCtwUVuS41I9VOTwXceltZNzXVk70YpPgjkcc7/xrXpsIUTwSOAihGgR/wvQ6XVcGp4ODfWHivS8mdZOznXsXgeAuf8EFLO1VY8thAgeCVyEEC3ib3Ku/pylgVwVcwPJuS5P4NJ6tyutqgznwR/d5x04qdWOK4QIPglchBAt4m/lXL03Rp/2XJe5oRyXIAwVOX75HlQnhoSeGLv0brXjCiGCTwIXIUSL+DNU5FJVz2KJDc0OargAXesPFXnWJUqf2GrHFEKEhgQuQogW8R4q8p2cW7swnbmBnhPPdGiH78CltRZYdOVnoeYcAMWISZJyhehwJHARQrSIP0NFXgslmnz3nOjToR0NDBU1FPA0l2PvN+529B6BIdzWKscUQoSOBC5CiBbxpwCdw1lTi6WhCrgNzSpyeXpcWj5UpKlOnPu+A8Akw0RCdEgSuAghWsRVe6iogRwXvRfF1Ej1W3MDgUtrJue6juxAqyhGCYvG1Gt4i48nhAg9CVyEEC3i8GeoSJ9R1EjwoS8F4Ki7yKKenNsKlXMde6qHifpPQDGYWnw8IUToSeAihGgRl9dQke/kXD24aWy9oYZ7XKoDlxauVaRWluA8vNV9LhkmEqLDksBFCNEizepxaST4aHg6dPVQUQtXh3b+8j2oLgxdemNM6NmiYwkh2o4ELkKIFnG1UuDSYAE6tXWScx179NotZ7boOEKItiWBixCiRRx1hoo0rf5wkV85Lg31uDhbnpyrluSi5h0CxYC537iAjyOEaHsSuAghWsTl8j20U5tfPS4NFaBTW14513VsFwCGpFSUsKiAjyOEaHsSuAghWqRuoOJruMif5NyGCtC1xiKLzqyd7mN0HxTwMYQQ7YMELkKIFqkbqPhaIbo5Q0WtXcdF0zRPj4uxx+CAjiGEaD8kcBFCBEzVNM/iiTpfCy36l5zb+CKLgSbnqoXH0coLwWjGmJQW0DGEEO2HBC5CiIDVzW+BBoaK/JkOXV2AzqVquNTaM5VatlaR65h7mMjYtT+KyRLQMYQQ7YcELkKIgNXOb7HqlW99Jec2owAdePe6tLTHxZVVPUwk+S1CdAoSuAghAlY7nyXM4g5cGh0qMhobPFbtwKV2nktLknM1VcV5fLd7f8lvEaJTkMBFCBEwvdy/0aB4Ag+n6mP4yI+hIoOieIITR60p0Y4WJOeqeYehqgzM4Ri69Gn2/kKI9kcCFyFEwGoP4+iBRWM9Lk2tN1Qzs6hmSnRNj0vzh4o8+S3dBqAYGu7tEUJ0HBK4CCECpgcuZqOhJnDxmePiDkQa63GBmiJ03jkugfe4eOq39JD8FiE6CwlchBAB04MKo9GA2eTuEQm0jkvt52vnuHgq5xqa1+OiuZy4Tux1t0/yW4ToNCRwEUIErKbHxb+hoqZ6XPQp0XZHzVCRfjxjM3tcXNn7wWlHCYvGENejWfsKIdqvZgcuhw4d4i9/+QsXXXQRgwcPZtasWT63e/fddznvvPMYNmwYF154IWvWrKm3TUlJCffddx9jxoxh5MiR3HHHHWRnZzf/VQgh2kRNjkvtoaLAA5f4aCsAR3PKap1D82vfujzVcrsPQlHkO5oQnUWzP8379u1j7dq19O7dm7Q031UoP/30U+6//36mT5/O4sWLycjIYN68eWzdutVruzvvvJP169fzwAMP8Nhjj3HgwAFuuukmnE5nQC9GCBFazlpDQJ7KtwGuVQQwtG88AD/tz605R/VQkbGZQ0Wu6vwWGSYSonMxNXeHyZMnM3XqVAAWLFjAjh076m3z1FNPMXPmTO68804Axo0bx969e3n66adZvHgxAFu2bOHbb79lyZIlTJw4EYC+ffsyY8YMPv/8c2bMmBHoaxJChIhT1XNcFE9g0ejq0E0M9wxLS+Ct1b+w50ghVXYXVovRM+W6Ocm5mqPKPVSELKwoRGfT7B4Xg6HxXY4cOcLBgweZPn261+MzZsxgw4YN2O12ANatW4fNZuOMM87wbJOamsqgQYNYt25dc5slhGgDvnpcWpLj0jU+gi4xYThdGrsOFbj3DWA6tOvEXlBdKFEJKLYkv/cTQrR/ze5xaUpmZibg7j2pLS0tDYfDwZEjR0hLSyMzM5O+ffuiKN43o9TUVM8xAtVUrYhA6ImBzU0QFM0n1zp0Wnqt9b4Vk8mA2eROrFU1rd5nUM97CbOamvx8ZvTvwpebjrLjQB6nD0ry1HHxZ1+d/YS7Wq45ZTBmc/uo3yLv69CRax06bXGtWz1wKSoqAsBms3k9rv+sP19cXEx0dHS9/WNiYnwOP/nLYFCIi4sMeP+m2GzhQTu28CbXOnQCvdbWMDMA4VYzUZHuBQxNFlO9z6A+ehQfF9Hk5/OMjBS+3HSUnw7kExsb4Rl6SoiPIrY6ebcp5Tm/ABDTbzjRQbwfBELe16Ej1zp0QnmtWz1waWuqqlFcXN7qxzUaDdhs4RQXV/hcEVe0HrnWodPSa11YXAGApmm4qqvdlpRWUVBQ5rVdVZU74b6ywl7vubpSEsIxGw3kFFSwfc9Jz+OlpRVofiTua047VcfcgUtVTB+cTZwvVOR9HTpyrUOnta61zRbud69NqwcuMTExgHuqc2Jioufx4uJir+dtNhsnTpyot39RUZFnm0D5GmNvLS6XGtTjixpyrUMn0Gttd9TM+NGTc+0OV71j6QXlDDT9+TQqCgN6x7IjM5+NO2sCF0Xz77PtPL7fnd8SHoMa0QWtnb2H5H0dOnKtQyeU17rVB6VSU1MB6uWpZGZmYjab6dmzp2e7AwcOoGneMxAOHDjgOYYQon3Tb1SmpgrQ+TkdWjc8NQGALftqpkX7O6vIdWIfAMau/evl0AkhOr5WD1x69uxJnz59WLVqldfjK1asYPz48Vgs7nHwSZMmUVRUxIYNGzzbHDhwgJ07dzJp0qTWbpYQIgg85fiNBs9UZ18F6GpWh/YvUXZYmjtwOZJdCoCiuPPX/OEp89813a/thRAdS7OHiioqKli7di0AWVlZlJaWeoKUMWPGEB8fz+23384999xDr169GDt2LCtWrGD79u289tprnuOMHDmSiRMnct9993HvvfditVp5/PHHGTBgANOmTWullyeECKaaHheDZ8ZP3QJ0LlXFpTav+m1yXATJceGcLKjwHN8fmqbiOunObzF27e/XPkKIjqXZgUteXh7z58/3ekz/+dVXX2Xs2LHMmjWLiooKFi9ezAsvvEDfvn1ZtGgRI0eO9NrviSee4OGHH+Yvf/kLTqeTiRMn8uc//xmTqdPlDAvRKdWs3Kw0uDq001nzc1MF6GoblprAyc1Hq4/v335qwTGwl4PJiiGhl9/nEkJ0HM2OEFJSUtizZ0+T282ePZvZs2c3uk10dDQPPfQQDz30UHObIYRoB7yHiqor59bJcandA2My+Z9zMjwtgS89gUszh4mS01AM7aN+ixCidUl1HiFEwPTeFJPR4JnKWHeoSK+a65555P8tZ0CvWCzVQ0vNTsxNlmEiITorCVyEEAGr6XFRGkzOdVTXd2luRWuzycjA3nGA/wssSmKuEJ2fBC5CiID5Ss6tN1Tk5wKLvgyvnl3kT4+LWpqHVpoHigFjkpRUEKKzksBFCBEwZ62Vm/U8FEfd5FxX82YU1Xb6wCR6dInk9IFNL5SoDxMZEnqiWKTUuxCdlUzfEUIEzOmqP1RUt+y3vytD+2KLsPD3G8f6ta3rpF54ToaJhOjMpMdFCBGwmsDF4BnOqZ+c685xCSRwaY7aFXOFEJ2XBC5CiIB5DRWZGkjOdQWe4+IvzV6Omn8EkBlFQnR2ErgIIQLma6iobgG6lgwV+ct1cj9oGkp0IobIuKCdRwjR9iRwEUIEzOU1VFSdnNvQrKJgBi4yDVqIU4YELkKIgDn8GSpqwXRof0l+ixCnDglchBABc9UaKjIZmshxCVKPi6Y6cWVnAhK4CHEqkMBFCBEwh8tHATqXhqbV5LkEe6jIdXI/uOwo1igMsd2Ccg4hRPshgYsQImCuWkNF5loLIdZO0A124OI8tAUAY89hKIrc0oTo7ORTLoQImKfHxaR4leWvPVxUk+MSnNWaXYe3udvQe2RQji+EaF8kcBFCBMyT42IweC2i6BW4BDHHRS06iVp4HBQjpp5DW/34Qoj2RwIXIUTA9CEho1HBoCieVZx9DRU1d3Vov85/aKv7/N3SUSwRrX58IUT7I4GLECJgzjpVcX2V/Q9mjovz8Fb3eXtntPqxhRDtkwQuQoiA1fS46IFLdY+L01eOS+vebrSqMlzH3YXnJL9FiFOHBC5CiICoqoZaPe1Z703xVYQuWDkuzqM7QHNhiO2GwZbUqscWQrRfErgIIQJSOzjRc1vMPoaKnEEaKvLkt/TKaNXjCiHaNwlchBABqR24eHpc9IUWvYaKXF7btAZNdeE8st19TslvEeKUIoGLECIgtWcO6T0unhwXXwXoWjHHxXXyF6gqA2skxuR+rXZcIUT7J4GLECIgeo+L0aCgKHrg4mNWURByXPRhIlPP4SiG4BS2E0K0TxK4CCEC4nTVr8/iSc71NauoFQMXl0yDFuKUJYGLECIg+nCQyVCzRpE+HOSz5H8rBS5e1XJTpFquEKcaCVyEEAHx2ePiCVxq5bi08lCRXnTO2C0dxRrZKscUQnQcErgIIQJS0+NSO3DRk3ODV4DOefRn97l6jWiV4wkhOhYJXIQQAfHV46L3qgSr5L+maai5BwEwdu3f4uMJIToeCVyEEAHxBC7GmhwXU6M5Li2f/aOVF6JVFINiwBDfs8XHE0J0PBK4CCECUhO4+MhxqQ5WVFXDpXovC9ASau4hAAyx3VFMlhYfTwjR8UjgIoQIiCfHxVh/VpGj+rnaQ0atkePi0gOXLr1bfCwhRMdkCsZBr7nmGjZu3Ojzuf/7v/9j5syZDW6zYsUK0tLSgtEsIUQr8vS41ErONdZJznXUqudiMim0lCe/pUuvFh9LCNExBSVw+etf/0ppaanXY6+88gqff/4548eP9zw2atQo7r33Xq/tUlJSgtEkIUQrayw5Vx8q0gMXo0HBaGjNHpc+LT6WEKJjCkrg0q9f/bVDfv/733PGGWcQHx/vecxms5GRkRGMJgghgsxXAbq6ybkOH8FNoNSKYrSyfACMCdLjIsSpKiQ5Lj/++CNHjx7lggsuCMXphBAh4LsAnTuIcdQZKmqN/BY17zAASkwyiiW8xccTQnRMQelxqWv58uVEREQwZcoUr8c3btxIRkYGLpeLESNGMH/+fEaPHt3i87XGt7u6jNU3XmMrrnArfJNrHTotudbVk4Uwmwyez5zV4p7yrKruz6GmafW2CZQz3z1MZErsE5TPeLDJ+zp05FqHTltc66AHLk6nk5UrVzJ58mQiIiI8j48ePZqLLrqIPn36kJ2dzZIlS7juuutYunQpI0eODPh8BoNCXFzwyoDbbPJNL1TkWodOINfabHHfPiIjLJ7PnC3afRzF6P4cniisAiDMYmrx5/Jk0VEAonulExvEz3iwyfs6dORah04or3XQA5f169eTn5/PrFmzvB6/4447vH4+++yzmTVrFs888wyLFy8O+HyqqlFcXB7w/g0xGg3YbOEUF1fgqjXFU7Q+udah05JrXVJaCYDqVCkoKAPAUeUAoLzCQUFBGfnVjxsMeLYJVEXWfgDskd1afKy2IO/r0JFrHTqtda1ttnC/e22CHrgsX76c2NhYJk6c2Oh2ERERnHXWWXz22WctPqfTGbw3qsulBvX4ooZc69AJ5FrbHe7tDYri2degVOe4OFw4nSqVdifgTtptye9Ss5ejFme7f4jr1aHfF/K+Dh251qETymsd1EGpyspKvvzyS84//3zMZnMwTyWECLGa5Nxas4pMdQrQtdI6Ra7c6sTcqASUsKgWHUsI0bEFNXBZvXo15eXlfs0mKi8v5+uvv2bYsGHBbJIQopX4LvnvuwBdS2cV6aX+jVK/RYhTXlCHij755BO6d+/Oaaed5vX4pk2bePHFFzn33HPp0aMH2dnZvPTSS+Tk5PDkk08Gs0lCiFZSU/K/4bWKWq/H5SAgpf6FEEEMXIqKivjmm2+YO3cuiuJd6jsxMRGHw8Hjjz9OYWEh4eHhjBw5kgcffJDhw4cHq0lCiFbU2OrQjjoF6FoauKh5eo+LBC5CnOqCFrjExMSwY8cOn8/17t2bJUuWBOvUQogQ8DVUZK5bObcVelw0RxVq4XFAelyEELI6tBAiQD6HikyK13OtkeOi5h8BTUOJiMUQERvwcYQQnYMELkKIgOh5LD6Hiloxx8WT3yLrEwkhkMBFCBEgp9rwUJFLbb0cl5oZRTJMJISQwEUIESBX9XCQ0WePS+vVcXFVBy4GmQothEACFyFEgDy9KV45LjXJuZqmtTjHRXM5UPOzAOlxEUK4SeAihAiIvi6J0WuoqKb3xaXWClxMxoDO4Ty0FTQXWCNRohICb6wQotOQwEUIERB9OMjsowCd+3m1RTkurtyDVH79onv//hPq1YMSQpyaJHARQgTEpTY8qwjcw0XOAHNc1JJcKlY+Ds4qjD2GYB13eSu0WAjRGUjgIoQIiMNZf1aRwaB4Voh2ujQcThfQvBwXraqMilX/h1ZRhCE+hfBzb0MxBH0heyFEByGBixAiIC61fgE6qClC53CpzZ5VpLmcVHyxCLXgGEpkHOHn341iiWjFVgshOjoJXIQQAXF6knO9c0/MtRZa1HNcTH4GLlXrX8N1bBeYwwg//y4MUfGt2GIhRGcggYsQIiBOH9OhodYK0c3scXEe34Nj99eAQvjU2zBKpVwhhA8SuAghAuL0UYAOvFeI9reOi6Y6qfp2qXvbgWdh6jmstZsrhOgkJHARQjSbpmk1M4bq5bhUl/13aX5Ph3b8/BVqwVEUaxTWMZcGocVCiM5CAhchRLOpmoZW/W9jncBFL0Lnb3KuWlZA1aZlAFjGzkYJi2r9BgshOg0JXIQQzeZ0ap5/N5jj4vQvcKn64W1wVGJITMU84MwgtFYI0ZlI4CKEaDZ9ZWjwkeNi8pGc20COi/PYLpy/fA8ohE2cg6LILUkI0Ti5Swghmk3Pb1EAo8H3dGi7U/XUevHV46KpTqrWVyfkDj4HY2Kf4DVYCNFpSOAihGi2mhlFhnprCOk9MBVVTs9jvgIX54Ef3YXmwqKxjr4kiK0VQnQmErgIIZrN6WOdIp3e49JU4OLK3u8+RtoYFGtkMJophOiEJHARQjSb08c6RTr9sfLqwMWgKBgN9bdTcw8CYEzsG6RWCiE6IwlchBDNpg8V+epxMXl6XKoXWPSV36KpuHIPAWDo0idIrRRCdEYSuAghmk0v9++rx8VcvchiZXWPi8/ApegkOCrBaMEQ2y2ILRVCdDYSuAghmq2xwMVUJ8fFZ35L9TCRoUsvFIMxSK0UQnRGErgIIZqtZqjIj8DFxzaunIMAGLv0DlILhRCdlQQuQohmq+lx8TGryKQn5zac4+JJzJX8FiFEM0ngIkQHU1Hl5KvNRykoqWqzNjSnx8VUJ3DxSsyVonNCiGaSwEWIDua7HSd4/Yu9fPRtZpu1obEeF1OdAnR1e1y0ouxaibndg9xSIURnI4GLEB2M3tNyJLuszdrQ6KwivcfF7jvHxZOYm9BTEnOFEM0mgYsQHUx5pQOAE/nlaJrWxNbB0VjgYqx+TG9a3R4Xl+S3CCFaQAIXIToYvSJtRZWT4nJHwMcpq3Tw/575jsff/BFVbV4A1FgBurqBSt2fVX1GkeS3CCECEJTA5YMPPmDAgAH1/nvssce8tnv33Xc577zzGDZsGBdeeCFr1qwJRnOE6FTKKmvWADqRF/hwUeaxYk7ml7N60xHe+GJvs/b19Lj4mDFUN5ipHbhIxVwhREuZgnnwF198kejoaM/PycnJnn9/+umn3H///dxyyy2MGzeOFStWMG/ePF5//XUyMjKC2SwhOrTy2oFLfjkDesUFdJzSWr01n//vCAkxYZx7ek+/9vUELj7WIKo7fFQ7x0UrzgZHBRjNGOIkMVcI0XxBDVyGDBlCfHy8z+eeeuopZs6cyZ133gnAuHHj2Lt3L08//TSLFy8OZrOE6ND0HBdwBy6BKqlwHycy3ExZhYO3vtxHl5gwRvZPbHJfz1CRjx6Xusm4tXtc9MJzkpgrhAhUm+S4HDlyhIMHDzJ9+nSvx2fMmMGGDRuw2+1t0SwhOgQ9xwXgRF4LApdy9+fs7FEpnDOyBxrw/Mc/c/BEcZP71vS4+JgO3UiOiyTmCiFaKqg9LrNmzaKgoIDu3btz2WWXceONN2I0GsnMdNef6NvXezn7tLQ0HA4HR44cIS0tLeDz+voW2FL6TAmjj1kUonV1xGu9dV8uW/bmcNV56VhMwetJ0DTNe6iooCLg97t+nJhIC5dPTiO3qJKfMvN48r3t/P2GscRGWxvcV8/lNZuN9c5vtXi/fmutbbQ8d36LOblvUD6n7VlHfF93VHKtQ6ctrnVQApfExERuv/12RowYgaIorF69mieeeIKTJ0/yl7/8haKiIgBsNpvXfvrP+vOBMBgU4uIiA298E2y28KAdW3jrSNf6o/X/Y//RIiaOSmHM4K5BO09FlRNXrRlAOYUVREWH+yyr35RKp7vXxBZpIS42kj/fMJb/t/AbDp8o4fvdOVwxbUCD+xqrzxcdZa33eYsv9K7oa4sOIy4uEk3TKKpOzI1LG4w1iJ/T9qwjva87OrnWoRPKax2UwOXMM8/kzDPP9Pw8ceJErFYrr7zyCrfcckswTumhqhrFxYF3nzfEaDRgs4VTXFyBq7qbXARHR7zWeYUVABw7WUxBt+gmtg5cfnElAEaDgslooMrhYu+BXLp3aX4QkF/kbrMt0uq51lNPS+G/n+7ihx3HOX90SoP7llUPMzntTgoKvGc2VVR4By5Oh4uCgjJcRSdRq8rBaKbMGEd5QdsV0GsLHfF93VHJtQ6d1rrWNlu43702QR0qqm369On897//ZdeuXcTExABQUlJCYmJNImBxsXtsXX8+UE5n8N6oLpca1OOLGh3lWquaRkn1DJ2SMkdQ21xc6g4YIsJMxEVbOXyylKzsUpJim/9tR2+zLcriudaDe7tnKGVmFVFQXEl0hMXnvnaHewFFg0Gp93rrZr0Yq7dxnHAPERvie+LSDNABfrfB0FHe152BXOvQCeW1bpMBwNTUVABProsuMzMTs9lMz57+TckUoj0or6wZvimtCLwgnF/nqk7MjbCa6BofAQQ+s6i0utfEFlkTnMTbwkhJjEIDfj6Q3+C+Ln1Wka/k3AZmFbmk8JwQohWELHBZsWIFRqORwYMH07NnT/r06cOqVavqbTN+/HgsFt/f8oRoj/TZOeCuRhtM+vEjwswtClxUTaO0wh0E1Q5cAIaluUsYbM/Ma3B/R3MK0FUHMqq+RlGX3s1urxBC6IIyVHTDDTcwduxYBgxwJ/d99dVXvPPOO8yZM8czNHT77bdzzz330KtXL8aOHcuKFSvYvn07r732WjCaJETQFJfVClyC3eNSPRMoMsxE14TAA5eKKidq9WJCtkgLpSWVnueGpyaw8vvD7MjMR1U1DD56VTw9Lo0ssuj52WRAc9px5RwAZCq0EKJlghK49O3bl/fff58TJ06gqip9+vThvvvu45prrvFsM2vWLCoqKli8eDEvvPACffv2ZdGiRYwcOTIYTRIiaEpqVaAN+lBRdeASEWaiW7w7ITeQwEWvmhtmMWKuM307rUcM4VYTpRUODpwoJq17/ZwzvY6L0Y86LiaTAdfRn8FRiRIZhyFBhoKFEIELSuDy5z//2a/tZs+ezezZs4PRBCFCpthrqMjZyJYtV3uoKDnenZBbUu6grNJBZJjZ7+PoVXN9Jd+ajAaG9Ilj054cftqf12jg4msatq8cF0fmRvdzfUejKFJbQwgROLmDCNFCtYeKQpmcG2ZxzyyC5lfQ1XtcoiN8BzvD0hIA+KmBPBe95L/Rx1pF9YaKcOE8tMX979TRzWqnEELUJYGLEC1Ue6go2Mm5tXNcgIATdEsq3MFWVHgDgUuqO3A5cLzEKzDTOTw9LvWHigwGBYNS83hkwd6aYaLkwCtiCyEESOAiRIvVHiqyO1QcTlfQzqUHLuEtDFxKKxrvcYmNstIrOQqAHQfq97rohaYaKhhlqhXQhJ3Y6n5MhomEEK1A7iJCtFBJnR4JfZpxMOgrQ+v5LJ7AJcChoqgGCswBDK8eLtq+v37g4qgeKqo7LKTTHzfhwnz8J/djMkwkhGgFErgI0UJF5d7DQ8EcLiqrqplVBAQ8JVof3opuYKgIYHhqF8BdiM6lelfErOlxqT9UBDUJugPNx1CcMkwkhGg9ErgI0UJ6j4ue1xHMWi6e6dBW76GikwUVqLUWX2xKU0NFAKndbUSGmSirdHLgWInXc/qsIpOP5FyoKUI30nLQ/bMMEwkhWoncSYRoAadL9cz0SYxzT08O7lCRd3Jugi0Mk9GA06WSW1zZ2K5e9OTchtYiAneS7ZC+ehXdXK/n9FlFvirngrvHxYSLoZajgAwTCSFajwQuQrSAPuRiUBSSqwOXYA0VOV0qVdWLG0ZU57gYDIqnnktz8lyamg6t02cX1c1z8fS4NDRUZDIw0HyMMMWBEiHDREKI1iOBixAtoE8Vjo4we6YWB2uoSO/ZAQi31lS7DWRmkT5U1FhyLuDpcTlyspQqe81sKU8BuoZmFRkNNcNEqTJMJIRoPUGpnCvEqUJfYDE6wuKZ6VMapB6XiuphojCL0avwW3MDF5eqeir8NpacC+5p0TGRForK7BzNLSWtewyaptUUoDMa0DSNyrUvouYexpiUijG5H8lKhQwTCSGCQgIXIVpAr+FiizQTFe7+OAWrx6WsTn6LrmZKdJl/x6nOwVGAyPCmbwE9k6IoOpDPkZPuwMVVKwnYbFTQik7g3LseADX/CI7da7mq+gRFWgRRMkwkhGhF0n8rRAsUl7mDFFuEhUjPUFFwknPLa61TVFtzp0Tr6xRFhJl8luyvq2eSuxDdkexSoGaYCNw9Ls5juwAwxPfEPHw6xuT+OHEPZW1RB8owkRCiVUmPixAtUHuoyJPjEqShotrrFNXWrbrHpbDUTkWVk3Br4x/r0uo2N5XfouuZXDdwqd3jYqAqayfgzmWxjroQgJfe+5FDmYcx2hK5wK+zCCGEf+SrkBAtUHuoyJPjEuShoog6Q0URYWZiotxByJ7DhU0ex1PDpYn8Fl3PpGjAHbiomubpcVEUUBQN17HdAJh6DPbsYzBZyFVtmEzy3UgI0bokcBGiBbyHiqpzXCqDPVRUPxgYP7grAF9uPtLkcfShooYWWKyra3w4JqOBKoeLnMKKWlOhDah5R9CqSsEchiGxj2cfvXJuQ3VehBAiUHJXEQFxqSqq5n+l1s5K73GJjrQQFeQel5ric/UDjsmjeqAosPNgAVm5jSfp1qxT5F/gYjQYSEmMBNzToj3F54wGXNX5Lcau6SiGmoBKXzXaLIGLEKKVyV1FNJvDqXLfC9/z6Os/tnVT2pye41I7OdfhVLE7Wn+F6LJK3zkuAF1iwxnZPxGArzY13uvS3KEiqEnQPZxd6lV8Tk/MrT1MBDWrRjdU50UIIQIldxXRbNkF5eQUVrL3aJGnkuupSNO0WkNF5ur6KtXrFQVhuKi8yneOi+7c01MA+G7HiUYThEs8ybnND1yO1gpcLEZwHd8DgLH7IK/t9YBFelyEEK1N7iqi2Yqqq8UCFJVWtWFL2lal3eX5Ix4dYUFRFE+NlWAMF+k5Lr6GigDSe8aSkhiF3amybtuxBo9T4ulx8W9WEUCvZD1Bt8QzVNTTmAuOSrBGYkjo6bW9SXpchBBBIncV0WxFpTWBS2Gtf59q9PwWq9mI1eKuWxIZxLL/eo5LeAM9LoqieHpdVm8+iktVfW7X3BwXgJREd49LXnGV5/efanAHR6bug+rVatHXMJIeFyFEa5O7imi22j0uhadwj0tJWf2FCvXAJTg9Lr4r59Y2dnAyUeFm8oqr2Lov1+c2geS4RISZ6BITBsDBE8UA9FHcgUvdYSKoWXW6OcGREEL4QwIX0Wy1g5Ui6XHBFlkz5KLPLApGEbqGCtDVZjEbOSujOwBfbjrqcxvPdOhmBhV6nsuB48WYcNFDOwGAsUf9wGXC0K5cMy2dmeN6N+scQgjRFAlcRLOnNRdLjwtQK3CpVYE2WLVcNE3z9LjULflf1zkje2BQFPYcKeTwyRKv5xxOl2eV5+b0uEDtwKWEvqZsTLhQImIxxHSrt2241cQ5o1KIibI26xxCCNEUCVxOce99vZ87nviG7MIKv/epHaycyjkuJWV6uf9aQ0VBquVSaXd5AsyGZhXp4m1hnD7QPTV69Y/evS6l1esoGRSlyaUB6tITdCuqnPQ3V/e2dB+EoijNOo4QQrSEBC6nuC37ciivcrLrYL7f+0iOi1txdZJr7aGiYCXn6r0tJqOCxY+E14nD3L0gOw8WeD1eeyp0cwMOvccFIN3kDlzq1m8RQohgk8DlFKZpGvnF7sDjZIH/PS6181pqBzGnGn3IrPZQUVSQknPLaq0M7U/Akdo9BgXILar0GtoLJDFX1yUmjHCrESsOepncib++EnOFECKYZAW0U1h5ldNTQO5kfrlf+9gdLk+SKEBhyanb4+JZGTqy9lBRcHJcKvxIzK0tIsxE14QIjueVk3msmIz+XYCawMWfdYo0TcV1aBv2n79Es5djiErg8hgXxaUVGBWNEkMM0dFdAnxFQggRGAlcTmEFxTVBR7afPS76t3cF0HAHP3aHC4vZGIQWtm+eoSIfPS6tPauozI+p0HWldre5A5fjRZ7ApcSPGi6ay4nzlw3Yt61ELawpZKfmHGAkgHtWNNnW3nRv3ssQQogWk8DlFJZfUun5d3ZhBaqmYWhiGKKwOnCJt4VRXG7H4VQpLLOTFBse1La2R76GioKVnNtU8TlfUrvHsP6nE2QeK/Y81tRQkSPzf1RteAOtrDo3xhyOZchkDImpaKW5HDlwmOOHj2BVHBxKHk1GYC9HCCECJoHLKSy/Vo+Lw6lSWFJFvC2s0X30/JbYKAuK4s6hKCqtOuUCF5eqehJwoyN9TIeucKJpWqvNuGmq3L8vad1tgLvuih6U1lTNrV/u377jC6q+ex0AJSIWy7BpmAedg2Kp+d0auhTz352bADgnLCmwFyOEEC0ggcsprHaPC7jzXJoMXMrcwU5MlBXFoFQHLqFN0C2tcPCv139kcJ94rpjaP6TnrmmDEw33kFlUeM3HSB8qcrpU7A7VsxRASzW2MnRDeiRGYjEbqKhycTyvnB5dIimpqM7LqdXjomkaFRveoWrLcgDMg6dgHf8bFGP9IKlHl0gUBTQNjEaZBi2ECL2gBC4rV67k448/5ueff6a4uJjevXtzzTXXcMkll3i+gV5zzTVs3Lix3r4rVqwgLS0tGM0SddTucQH3zKJBfRrfRw9SYiItVC+ETEGIp0Rv+yWXrNwycosquXxyPwyG0P8B1Wu4RIabMRpqJudZze4Vol2qRlmlo9UCl6ZWhvbFaDDQJzmavUeLyDxW5A5c6uS4aC4nOcsXUbn9awAsoy/BkjGrwZ4ii9lI13h30q8soCiEaAtBCVxefvllevTowYIFC4iLi+O7777j/vvv58SJE8ybN8+z3ahRo7j33nu99k1JSQlGk4QPBdUzgqIjzJSUOzhZ0PTMopoeFwvG6oAh1D0u+44WAVDlcJFdWEHX+IiQnh98l/sH90KHUeFmisrslFY4muzB8lcgQ0XgznPZe7SIA8eKOXN4d68cF81pp/TLp3Ee3gaKgbAzr8U8cFKTx+yVHM3xvHLPCtBCCBFKQQlcnn32WeLj4z0/jx8/nsLCQl566SVuvfVWDNXfUG02GxkZGcFogvBDfrF7qGhArzg27c7mZH7TM4sKa/W46IFLqIvQ7Tta6Pn3kezStg1cfMzOiawOXFqzCF1Nuf/mfWRTq/Nc9ATdmunQRiq/Xozz8DYUk4WIabdhSBnh1zGnnJZCSbmd0QMlx0UIEXpB+cpUO2jRDRo0iNLSUsrL/asXIoJL0zTyq3tcBvWOA/Czx6U6cImyElu9Dk1RCAOXknI7x/Nq2nkku6SRrYPYDs/K0PWTXKOCUMulrJl1XHR64HIkp5Qqu8szVBSz5xOcmf8Dg5Gul/0RS5+Rfh+zX48Y7vnNSFJqVdIVQohQCVly7ubNm0lOTiYqquZmt3HjRjIyMnC5XIwYMYL58+czevToFp/L5EdJ9OYyVneLGztJ93hJ9VRmgCF93YFmTmEFBoPSaM6IPgU4ISaMsOr8jcIye6te88audebxYq+fj2SXBeX33ZTS6qGbmChLvfPrM3bKq5yt1raK6iAoOrL++RqTFB9BXLSVgpIqfjlWhNOlcrZ1J6a97plBUVNvJrzvcBzF/ldOFoHpbPeQ9kyudei0xbUOSeCyadMmVqxY4ZXPMnr0aC666CL69OlDdnY2S5Ys4brrrmPp0qWMHOn/t7+6DAaFuLjI1mi2TzZb55j2m1/dYxAbZWVgWiImowGnS8WlGEiI8z30oqqap8eld49Yz7BDcZk9KNfc17U+nOPubemZHM2RkyVk5ZQG9ffdkEqHO+jr2iWq3vnjY9ztVpXWey9WVK/o3DUp2q9japqGs+AEiiWcgb3j2LDjBLsOF5JhPshFEe6gJf6cq4kdPQXoPO/rjkCudejItQ6dUF7roAcuJ06c4K677mLs2LHMmTPH8/gdd9zhtd3ZZ5/NrFmzeOaZZ1i8eHHA51NVjeLi1h+OMhoN2GzhFBdX4HKprX78UDuUVQi467EUF5WTGBvG8bxy9hzIxawk+NynuMyOqmoogOpwYlDd16Gk3MHJnGIsptaZQdPYtd6+LweAc0Z259VVe8gtquRwVoHPIZtgyq0eVjMboKCgzOs5c/U04Zz8snrPBaq0OqfGZXc0eExN03DlHcHxyw/Y929ELToJwCXGcMZER1GyM47JUb9gUMA6dCrqwHMpLq7oVO/r9qyz3UPaM7nWodNa19pmC/e71yaogUtxcTE33XQTsbGxLFy40JOU60tERARnnXUWn332WYvP63QG743qcqlBPX6o5BS6hwbioq04nSrJce4prsdzyxjYK87nPnlF7mTeqAgzaGA1GTw9NfmFlXRp5SJ0da91lcPFweqhoiF94kmMDSOnsJKDx4oZ1Kd+XlUw6T1PkWHmeu+HCKs7gCspc3g951JVikrtzZ5p5HCq2KuPYzUb651PU104fv4Sx841qEUnap4wmEB1YXZVkGquANxB3y9KXzLGXYnLpaEo7mN1lvd1RyDXOnTkWodOKK910AKXyspKbr75ZkpKSnj77beJjo4O1qlEAPQaLvHR7j+iSXHuoKOxVaL1JNyYSHdSrqIoxEZZyC2qpLDU3uqBS10HjhXjUjXioq10iQmjZ1I0OYWVHMkuDXng4qvcvy6ygfWK3vt6P59tPMLdl49gaF/fvVq+6DVcFCC8TnKuK+cAleteQs077H7AaMLUcwSm1NGYemeAYqAyN4slb6wmyViEAmQlTWRkI18ihBCiPQtK4OJ0OrnzzjvJzMzk9ddfJzk5ucl9ysvL+frrrxk2bFgwmiTq0KvmxtvcQUiyHrg0skp0zYyimj/WsVHW6sCl/syi/ceKqLK7GNxKQYU+Dbp/SgyKotArKYof9+ZwJLu0VY7fHPrsnNorQ+uifKxXpGoa3+1w94Zs3JXdvMClOgAKs5o8a0lpjkqqNi3DseNzdxlbayTW0Zdg7jfeq0Q/QHjXvmTHDOPHHPd1GhMR+unjQgjRWoISuDz44IOsWbOGBQsWUFpaytatWz3PDR48mO3bt/Piiy9y7rnn0qNHD7Kzs3nppZfIycnhySefDEaTRB16j0tcdeCSVF0LJbuw4R4XPTiJrVV0TQ9i6gYuDqeLx97aSpXdxU0XDGb8kK4tbvPe6sJz/VNiAehZPR33cIgDlyq7iyqHO1nWZ4+Lj+nQh06UeIKd3YcKmnW+8jorQ7vys6hY9X9opXkAmNLGYR1/BYaImAaPkdrdxtHqwCXU+UBCCNGaghK4rF+/HoBHHnmk3nNfffUViYmJOBwOHn/8cQoLCwkPD2fkyJE8+OCDDB8+PBhNapGivDwOf7aUXoOHED98Ehisbd2kFivQe1yqh4r0HpecwgpUVfM5JVqvkGur0+MCNb0xukMn3XVDAF5asYv4aCsDGsid8YdLVfklSw9c3H+g9cDlWG4ZTpcaskquJdWJsiajwTMlvDZ9qKh2j8tP+/M8/84tqiSnsIJEP4fWaq9TpDntVH71DFppHkp0F8ImzsHUs+nPTGp3G+u2HQMaXhlaCCE6gqAELqtXr25ymyVLlgTj1EFx9Oct9CndChu3Urj1A8zpE7EMnoIhtuW9CG1B1TRPuf/4aGv1/8MwGRWcLo284kqff1T14CQ2siZwi9V7XEq8e1z0Sq2KAk6XxqIPfuJPc04PuMrt0ewyquwuwq1GUhLdAUtCTBjhVhMVVU6O55V7AplgK67uObFFmj1r+miaBqoLxWjyLLRYVuHwrBC9PdMduOgLFO46VOB34FJe5T5fRJiJqv+9j1qQhRJuI+Liv2AIt/l1DH2laKhZp0gIIToiWR3aD9HpY3hn8z7ODt9Nkr0Ix44vcOz4AkOX3mA0g6bhcrk4nleBKa4rPYeMwJjcH0NcD5R2mARZUu7A6XJPa46tDlwMBoXE2HCO55VzsqDcd+BSWrNOkU7vcSms0+OSeczdOzJzfG92Hiwg81gxT7yzjfvmnOZzeEW39Zdc3vt6P2eNSmH6mJ6ex/dW57ek9Yjx9AYpikLPpCj2Hink8MmS0AUu1a9VH3LRNJXKL5/BeWAzhoQUrIn9GWlxcMCZRGVhDo6CkyTlbmZweAmpXcxsOBnBwcwIJo3o7tf59KGiVMMxHD+5Z92FnXW930ELQLeESMIsRirtLk9gJYQQHZEELn5ISYrmRwbzXWE6/7zAhu3It7gOb0fNPeTZRgG6AxScpOrbbe4HzeEYE3q6gxtFAcWAS1MwmCwYreFgDkMxW1HCbZh6jcBgC83aL/oaRbYoi9fwij4l+mR+BUP71t/Pk5zrR46L3uMysFccU0/ryT9e3UR2YQWL3v+Je36TgcXsPcSiqhrLvsnk0w3ua/rm53swojF5lHvRzX118ls0TQPwBC6hTNDdeSgfgG7VvUf2LctxHnAXdVPzjkDeEa6tjqGc776PAlyhx1RlkBYF5Kyn9J2PMHUfjKnXCIwpg1EMvj+O5ZVOwpUqzixbBYB50NmYemU0q80Gg8LI/on8b3c2vbvKDD8hRMclgYsfDAaF/imxbN+fx057NyaffxdqcQ6u/OopqCh89O0Bjp4spoepgLGJpcRVHQNHBa4Te+sdT63+r7aq717HkJSKud94TKljGk20bKm6U6F1yfH6lGjfM4sKa61TpKtZr6imx6W4zE5uUSUK0LebjXCriTtnj+ChpZv5JauIe5/fwBlDu3Hm8G4kx0dQXGbn+Y9/Zld10mp6z1j2Hink9c/3EhdtJaNfl+oZRRpDooup/OYVHPt/QDEYOduSTGS4FS0rG1d+GIo1yj2rxmT1DOO0JqdL5Yed7sJu44Yk4zzyE/ZNywCwTrgKJSIW14m9HNy+ha5KHgaDQqnBxtGKCCKTutM3JYED2zaTYsjDUHgcR+FxHDu/QgmLdk9h7jceY3IailITUJZXOpkd8QMRrlKUmGSs464IqO03zhrE1dPS602pFkKIjkTuYH5K7+kOXPYeLmTyyBQMtkQMtkTA/cfsy5PF2B1xbHf0ZmOhlYd/OxalMMtdEEx1gabx1abDHD5ZjAUnVsWBVXESH66RFlVBbNkB1OxMqrIzqdrwJsau/TF2G4Cx6wCMyf1QzK2XEFxQZyq0Lrm61H+2j1oulXanJ9k2JtLirsqqqcREuqf1llY4cDhVzCaDp7elW5dIzx/J7l0iuf2SYTz74Q6KSqtY+f1BVn1/gPQUG0VFpbjKihgQZmfWqHgGJBWxMTKPLZlFrF9xBMvovgx37GCc7RcSN+Sjp7xqgK2yhCnhQOXPlL+3qlaLFbCEYYjqgjGxD4bEvhi79MGQ0BPFGPhQyU+ZeZSUO7BFWhjURaXiw+cADfPAs7EMPRcAc+poXt/Vj5M5xdxx6QieX76bskonCy4aRUTPWFYeHsiBQye4/jQDQ8JO4jywCa2iGMfO1Th2rkaJjMeQ0BNDVBcM0V3offIIg60H0VCIOOe3Ab8XFEWRoEUI0eHJXcxP6T1jAdh7pNCTcKnLPFaM3aESFW5GUSCvuIqtv+Rz+sDeGLv0BuDgiWLeOVyFQjI3zhrMzkP5rN2djT1fhXy49uzZjIs6imPfBtScTFzH9+A6vsd9AsWIoUtvjMlpGJPc/ynRXQLuUcgv8d3j0lgROn2YyGJWMOz+grKN74KmotiS+VVkAtuqelJUUk681UnR3k2cG7aHEdZyyj76AuyVaI4Kutsr+Ht4JYTV6m8qB8xAbPXPu6FiNwwDhunDKzvW0EtfnsdgwtT3dMwDJ6GYw7BnH+Tr1T/Qw5RHn4hyFEclaCqggb0CNf8Iav4R2PONZ39jchrG7oMw9hiMMTEVxej/x0CvxTJhYAL2r56BqjIMiX2xTrjSa7vIMDNOjPx0sIiySicRVhNpPdw5KYN6x7HzYAHfFXXhtKnnoU24CtexXTj2bcB5cDNaWT6usnxc1ccaXP3/Y93OZmBSmt9tFUKIzkgCFz+ldrdhMioUltrJKaokqVbyql6XY1DvOJLjI1j+3UG+3HyU0wfW5KwsW3cAcA8vjB/alfFDu3Ll1HSWfZPJl5uO8u2+ciZdcy6WoeeiFmfjzNrpDl5O7EUrzUPNyUTNycTBFwAo4TZ3ENO1P8au6Ri69PH7D7Ce4xJvs+I8uAXn0R0oETa6GaLpbzpOcXEUTqcDk6mmZ6Ko1I4VO9dF/YD9B/drQTGgFZ/kbOtJzrbuRHv/S8pUF6OAURFABaj+LjpsDkeJsGEIs2GIiMZsNlJZWs7hY3loTjsOzUhl95GMmX4hSlhNEm54UirffR9JVm4Zd543nGGpCeCy46qsYP3m/SQohfQPL8SVcwA15yBaVWlNULj5QzBZMSb2QYlKwBCV4P5/dBcMtiSUqAQUQ00uTmmFg22/5BChVDLZtQ419yCKNYrwqbehmLwTjvUE2B92uYeVhvSNx1idqD2odzyQyZ7DhdVTz42YUoZiShmK5pyD68QvqCU5aCW5qKW5HM08xKGKCCL7TPXzYgohROclgYufLGYj/VJi2X2ogH1HCr0Cl521ApcR/bqw8vtDnpkuvZKj2Xe0kJ8y8zAoChdOrMl6DbeamD62N19uOsovWUUUllYRG2XFYEvCYkuCQWcDoJbk4jqxF1d2Jq7s/ah5h9EqinEe2oLz0Bb3wYxmjP+/vTuPirreHz/+/Az74rAooKIgS4yAKCYuiGHS4r52U8vSNLfKvNHtl2Z1zbTldO+t2zXTm+3Z1dRb+StRK69pueCampgLIAIqKsswbLLM5/vHyEdHFiFRHHs9zuF05v15z8fXvM8085r36hOErlUgOu922Hn5W1Y1OdZcHZRnuoBeKaFT5heU/nJIK7cHZlxcqFLy2QYcAjpjH9gF+3ZRlJ49yV88kvBTCkFnh1PvcTiExlKZ9Sv7Nv1AQEU6bpSDopBT5UFmhRcRXTvj7R+A4uiC4uBsicXBGXR2ljkcFycsY2dvNXxjb6/Dy8uN/Pxi/PJKmP/pboxF5Twd3cUqaanW3ted7PPFnMwponNIK7B3YuWODH7YbQQUnn0ggY7dvVBVFbUwh8rsw1SdsvypZaZLPVtX0tmha+GD4uGHYu9E0Zls5rc4h6uuHE4CKDjfNR1di1Y1nlq9WVz1CqTOIZd2yg1s7Y6Lkx0lFyrJyDER1ObS6iDF3gn7dpFW9/pPxi4yik085Wr7+wcJIcS1ksSlESKDW1oSl6wC4qLaAJaD/1IvbowWHuiFVwsnYjr6kpySww+7s5g4qCNfbk4DoE/nNto8kmpeLZwIaasn9VQhe4+e01bRXE7XwjLXweG23gColeWYc09SlXOMqjOWP7XMZElurpgMrOj9sPcPx84/Env/CHB0pYPpFx712IFrbgUodjgY+oCqYi7K5Wx2Nu5qEU4VJVSm7qAydQcoCh2wQ2dXSbHOHZ9hidhdHLJwCO7Orl+cee9oDhPvaEmH0A68+tE+HB10LOodr/Uy/F7eemdeHB/DyZwiIus4OqC9nzs7UnK0lUU/7M7kh91Z2vWP1//GvEk9cHKwQ/FojaNHa4joh6qaMedlYc7PxlyUi1qUh9l0HrXoPObCs1BVaZmjdPHgQjeAiy9HcfPC8fbh2LfrVGtMblcsOe4UfClxsdPpMLT34pfj5/ktI98qcalN9ZlHrk6yjFkIISRxaYSIoJb8d9NxbWkuwPEsI1VmFW+9kzZH5O5u7UhOyWFHSg4RQV4cySzA3k5hWFyHWu/bzeBL6qlC9hypPXG5kmLviJ1fKHZ+odB5oKUnwXiGqpzjVFV/EedloZYUoBbmUFGYQ8XhH0FRUNy8GWpn2QzN7B2Ie7/JliXbF33z3wP8cuwsU3o509X1NJUZ+zHnZ6GjkiMVbUgPGc39V8yz8HR3woyOM5V6zGcsY0MdWuuvOWmp5q13rvdE5er9WzLPFvHL8fMs33gMgCG9A9l68Axn80tZ83M6o/uFWj1PUXTYtQzArmVAjXuqqhm1OB+zMQez8QyFxiI+25ZHrlnP/5t6Dx4e9S8pvnyvlMDWLayWkIMlyf3l+HlSMvIZ2Cuw3nuVXjxk0dVZ/ncVQgj5JGyEjhd/8Z/OLaGwpBy9q6O2hDc8wEubLBvi70FQGz3ppwv54NvDANwZ7V/nl283gw8rNx3nyMkCTCXljT5LRlEUFM826DzbcPlvcrWsiKqc41RmH6Iq6xDmglOoRbmUq3asK+3KA5OmY2dv/Rbw83JFRUdahS+9evTBqcf9mE3nSfpuJ18dc2Skvua2/dV7uRiLyrVt7oPbNnxztGvV3teSROTklfDvNYdQVbijcxtG3hFMSFsP3l59gA07T9K9o+9VezeqKYpOm/eCfwSbN6dysCKDziEtr5q0wKWhIoDOwTUPVAwPtLTjscyCeo8ruFBepZ0OLYmLEEJoHd+iIfRujvi3sixvOX6x1+Xwxc3IOgZaf6HfHWPpOakyqzg66BgcW/evah9PFwL83DGrKvuOnW+yeBVnd+wDo3HuPQ630a/i9uCbFMQ8yqvG4fzi2LVG0gLg611zZZGuRSuOVrVFRWe1a241bffcogvaUuiQG5i4eLg54uHmiIpl6C6ygxcP9zegKApdQlvRM8IPVYWPkn6jsurKHXSsVVaZ2Xf0HOeNl16/WVXZfsgyXFQ9RHg1l/e4RIXUTFz8fdxo4epAeaVZa7PabNybhapCKw9n9G5yOKIQQkji0khhAZ4AHMsqoKSsghNnTMClX9DVunf01YYH7urWzmrTttp0M1hWIO05cq6JI75E5+5NjquBfLN7jaXQ1VpfnIOTcaaQisoqrbx6gzkPt5qvo/q8orP5pdoJxMFtr98GerUJ8LP0gvj7uPHYiCirHowH7r4NdxcHss4VsS75ZF23wKyqvP9tCgu/PMisxdv5x4p97Dycw69pueQVXsDVyZ7o0JpJSG2qkww3Z3uCa+nlURRFe8+knMir9R4lZZWs22HZSXh4nyB012FDPSGEsDWSuDRS9X4ux7KMHMksQFXBz9u1xjCQvZ2OyUMiuKtbO4bEdrjqfWMMls3sUk7kaWfTXA/VS6G9WtSeSIX4e+DVwonCkgo27TullWsHLNbT43K2oBRVtdy7rvtfL8P7BHFnV38S7+9SY0hF7+rIA3ffBsA3W9M5mWOq9R5fbUlj5+GzloMQgUMn8lmy5hD/XHUAgB4RfjjY1zwNujYh/h4M6d2ByUMiaj1pGy710lUPN17pu10nKS6rpE1LV2IjbfNATyGEaGqSuDRSdeKSccbE/uOWYZ0re1uqRQZ5M+6ehm2x3qalG21aulJlVtmf2nTDRVfSNp/T155YONjrGHpxEnHS9hOUlVdSZTZjquWcompXDh/V1sNwvQW31TO+v6HOeUS9IvzoHNKSyiqV15bt1bbtr/bT/lPaOUmTBoXz+vRYhvTuYJWAxUU1PHnQKQqj4oPpElpzqXS16lVSx7KMbD142upaUWkF3+3KBGDEHcF1Jj9CCPFHI7P9GqmVhzNeLZzIN13QdlGtK3FprG4GX77ddoI9R85Z/cL++cBp1u88SXlFlVV97xZO9I5qQ/eOvlbJUWWVmYOpufx88DQXKqqYMjRSSzjq2jX3cn2i2rB+x0nOFpSycU8WvTu1QcWy7UptE4fdXRyw0ylUmS0HHwb73/jE5WoURWHykAgWf/0rhzPy+ff/P8TxbCNjEkI5klnApxsse7kM7d1Bm8cyKj6YEX2CLIcqqhDSxMNfPp4uDI4NZO32DD5e9xveemftvbRuRwZl5VW093Wn28XeOCGEEJK4NJqiKNzWzoOdh89SWWX5ou54cd7LtYox+PDtthP8mpbLhfIqdDr4/PujbNl/utb6541lHM0ysvyHY3QP9yXG4MORkwVs+/WMNrQD8K/VB3j2wa44OdiRX1j7OUWXs7fTMbxPEEu/TWHdjpNaD4re1bHWX/6KouDp7kjuxcMbm6PHpSHcXRz4y5ho7RTqjXuySDtl5ExeCVVmlV4Rfoy4w/pYbJ1OoVNQw+a1/B4j44M5V1DKzsNneefLgzz/cDdcne3ZuCdLuy5zW4QQ4hJJXH6H29p5svPwWcCyh0hjly/Xpb2vOz6ezpwrKON/+7LYmXKWjBwTCjCsTxCdgi/bgE21nJu05cBpcvJK+PnAaX4+cCnB0bs60CPCj+2/niH9dCHvf5PCYyM7XTZUVHePC0DPCD/W7sjg1PliVm9OBWoOCV3O092J3MIL6BSFDq1vzsQFLInIfX1DCGnrwdJvU0g/bZnvEtbOg4mDwq/LidL1xqMoPDo4nDzTBY5nGfnnqv2EtvOgvNJMcFs9XWpZkSSEEH9kkrj8Dre1uzRk0FTDRGDpuehm8GV98klWbbIkC+4uDkwbFklkUM1dY0P8PRjQM4BjWUZ+OnCKQ+l5BPi14I7ObekS2hJ7Ox0xBl/+vmIfe46eY8XGYxQUVQ8V1T95VqdTGNEniHe//lX7cq9tRVG16lVT/j5uODk2bAJrc4q+rRVzJ3bno7WHqVJVZtzXGQf75pny5WBvx5Ojonjlsz2czS/lvNHSKzYqPviGJ1JCCHGzk8Tld2jn446Lkz2lFypr7N9yrboZfFh/cclucFs9j4/oVG/viKIohLX31CYNXymsvSeTBoXz3jcp2jb4djqFFg3YE+R2gw8Bfu6czLEsca6vx6V6EuuN3HjuWvl6ujBr3O3NHQZgmTuUeH8XFny6m+KySjoGeBJRxxEHQgjxRyaJy++g0ylMGGDgxGlTrbuiXovgNnoG9QrETqcwNK5DnTuqNkavyNacKyjlq58spzp7tXBq0LyJ6pUx1cuBa1tRVO3Orv4Ul1Vwb/f2ddYR9fPzduXpMdFs2HmS4X2Crv4EIYT4A5LE5XfqEe5Hj3C/Jr+voij86c6Qq1dspCG9O3C2oJStB8/Q2tv16k+4KCq4JaH+HhzPNtY4IPJy/q3cmDo0ss7romGC2uiZPrz2gxuFEEJI4vKHoSgKEwZ0pGOAl9UcnYY8b8Z9Uew/dp5ekU2fqAkhhBCNIYnLH4i9na7BZ+1cTu/qyB1d2l6HiIQQQojGkZ1zhRBCCGEzJHERQgghhM2QxEUIIYQQNkMSFyGEEELYDElchBBCCGEzJHERQgghhM2QxEUIIYQQNkMSFyGEEELYjGZNXFJTU5k4cSLR0dHExcXxxhtvUF5e3pwhCSGEEOIm1mw75xqNRiZMmECHDh1YuHAhOTk5vP7665SVlfHXv/61ucISQgghxE2s2RKXFStWUFxczDvvvIOnpycAVVVVzJs3j2nTpuHnJ+fiCCGEEMJasw0VbdmyhdjYWC1pARg4cCBms5mtW7c2V1hCCCGEuIk1W49LWloa9913n1WZXq/Hx8eHtLS0a7q3vX3T52N2djqr/4rrR9r6xpG2vnGkrW8caesbpznautkSl8LCQvR6fY1yDw8PjEbj776vTqfg5eV2LaHVS693uW73FtakrW8caesbR9r6xpG2vnFuZFvfcumooijNHYIQQgghrpNmS1z0ej0mk6lGudFoxMPDoxkiEkIIIcTNrtkSl+Dg4BpzWUwmE+fOnSM4OLiZohJCCCHEzazZEpf4+Hi2bdtGYWGhVrZ+/Xp0Oh1xcXHNFZYQQgghbmKKqqpqc/zDRqORwYMHExQUxLRp07QN6IYOHSob0AkhhBCiVs2WuIBly//58+ezb98+3NzcGD58OImJiTg6OjZXSEIIIYS4iTVr4iKEEEII0Ri33HJoIYQQQty6JHERQgghhM2QxEUIIYQQNkMSFyGEEELYDElchBBCCGEzJHERQgghhM2QxEUIIYQQNkMSl6tITU1l4sSJREdHExcXxxtvvEF5eXlzh2XT1q1bx2OPPUZ8fDzR0dEMHz6c1atXc+WWQqtWraJ///5ERUUxbNgwNm3a1EwR3zqKi4uJj4/HYDBw8OBBq2vS3k3jq6++YsSIEURFRdGzZ08mT55MWVmZdv1///sfw4YNIyoqiv79+/Pf//63GaO1XRs3buT++++na9eu9OnThz//+c9kZmbWqCfv68bJyMjgr3/9K8OHDyciIoIhQ4bUWq8h7WoymZgzZw49evSga9euzJw5k7Nnz15zjJK41MNoNDJhwgQqKipYuHAhiYmJrFy5ktdff725Q7NpH3/8MS4uLsyePZvFixcTHx/Piy++yKJFi7Q6a9eu5cUXX2TgwIEsXbqU6OhoZsyYwS+//NJ8gd8C3n33XaqqqmqUS3s3jcWLFzN//nwGDRrEBx98wMsvv0y7du20Nt+9ezczZswgOjqapUuXMnDgQJ5//nnWr1/fzJHbluTkZGbMmEFoaCiLFi1izpw5/Pbbb0yaNMkqSZT3deMdO3aMzZs3ExgYSEhISK11GtquTz31FFu3buWll17i73//O+np6UyZMoXKysprC1IVdVqyZIkaHR2t5ufna2UrVqxQw8PD1TNnzjRfYDYuNze3RtkLL7yg3n777WpVVZWqqqp67733qk8//bRVnTFjxqiTJ0++ITHeio4fP65GR0ery5cvV8PCwtQDBw5o16S9r11qaqoaERGh/vjjj3XWmTRpkjpmzBirsqefflodOHDg9Q7vlvLiiy+qCQkJqtls1sq2b9+uhoWFqbt27dLK5H3deNWfwaqqqrNmzVIHDx5co05D2nXv3r1qWFiY+tNPP2llqampqsFgUNeuXXtNMUqPSz22bNlCbGwsnp6eWtnAgQMxm81s3bq1+QKzcd7e3jXKwsPDKSoqoqSkhMzMTE6cOMHAgQOt6gwaNIjt27fLUN3vtGDBAsaOHUtQUJBVubR30/jyyy9p164dffv2rfV6eXk5ycnJDBgwwKp80KBBpKamkpWVdSPCvCVUVlbi5uaGoihaWYsWLQC0IWd5X/8+Ol39aUFD23XLli3o9Xri4uK0OsHBwYSHh7Nly5Zri/Gann2LS0tLIzg42KpMr9fj4+NDWlpaM0V1a9qzZw9+fn64u7trbXvlF2xISAgVFRW1jmOL+q1fv56jR4/yxBNP1Lgm7d009u/fT1hYGO+++y6xsbF06tSJsWPHsn//fgBOnjxJRUVFjc+U6u54+UxpuFGjRpGamsrnn3+OyWQiMzOTN998k4iICG6//XZA3tfXS0PbNS0tjaCgIKvkEizJy7W+1yVxqUdhYSF6vb5GuYeHB0ajsRkiujXt3r2bpKQkJk2aBKC17ZVtX/1Y2r5xSktLef3110lMTMTd3b3GdWnvpnHu3Dl+/vln1qxZw9y5c1m0aBGKojBp0iRyc3OlnZtQTEwM77zzDv/4xz+IiYnh7rvvJjc3l6VLl2JnZwfI+/p6aWi7FhYWar1gl2uK709JXESzOnPmDImJifTs2ZPx48c3dzi3pMWLF9OyZUvuu+++5g7llqaqKiUlJbz99tsMGDCAvn37snjxYlRVZdmyZc0d3i1l7969PPvss4wePZpPPvmEt99+G7PZzNSpU60m54pbkyQu9dDr9ZhMphrlRqMRDw+PZojo1lJYWMiUKVPw9PRk4cKF2thqddte2faFhYVW18XVZWdn8+GHHzJz5kxMJhOFhYWUlJQAUFJSQnFxsbR3E9Hr9Xh6etKxY0etzNPTk4iICI4fPy7t3IQWLFhAr169mD17Nr169WLAgAG89957pKSksGbNGkA+R66XhrarXq+nqKioxvOb4vtTEpd61DYWZzKZOHfuXI1xatE4ZWVlTJs2DZPJxPvvv2/VpVjdtle2fVpaGg4ODrRv3/6GxmrLsrKyqKioYOrUqXTv3p3u3bszffp0AMaPH8/EiROlvZtIaGhondcuXLhAQEAADg4OtbYzIJ8pjZCammqVIAK0bt0aLy8vTp48CcjnyPXS0HYNDg4mPT29xv5c6enp1/xel8SlHvHx8Wzbtk3LJMEyyVGn01nNlBaNU1lZyVNPPUVaWhrvv/8+fn5+Vtfbt29Phw4dauxtkZSURGxsLI6OjjcyXJsWHh7Op59+avX33HPPATBv3jzmzp0r7d1E+vXrR0FBAYcPH9bK8vPzOXToEJGRkTg6OtKzZ082bNhg9bykpCRCQkJo167djQ7ZZrVt25aUlBSrsuzsbPLz8/H39wfkc+R6aWi7xsfHYzQa2b59u1YnPT2dlJQU4uPjrykG+2t69i1u7NixfPbZZzzxxBNMmzaNnJwc3njjDcaOHVvjy1Y03Lx589i0aROzZ8+mqKjIatOiiIgIHB0defLJJ3nmmWcICAigZ8+eJCUlceDAAZkr0Eh6vZ6ePXvWei0yMpLIyEgAae8mcPfddxMVFcXMmTNJTEzEycmJ9957D0dHRx588EEAHnvsMcaPH89LL73EwIEDSU5O5ttvv+Wtt95q5uhty9ixY3n11VdZsGABCQkJFBQUaHO5Ll+mK+/rxistLWXz5s2AJRksKirSkpQePXrg7e3doHat3tF4zpw5zJo1CycnJ9566y0MBgP33nvvNcWoqFf24wgrqampzJ8/n3379uHm5sbw4cNJTEyUbP0aJCQkkJ2dXeu1jRs3ar88V61axdKlSzl16hRBQUE8/fTT9OvX70aGektKTk5m/PjxrF69mqioKK1c2vva5eXl8dprr7Fp0yYqKiqIiYnhueeesxpG2rhxI//85z9JT0+nbdu2TJ06lT/96U/NGLXtUVWVFStWsHz5cjIzM3FzcyM6OprExMQau73K+7pxsrKyuOuuu2q99umnn2o/hBrSriaTiddee43vv/+eyspK+vTpwwsvvHDNP/wlcRFCCCGEzZA5LkIIIYSwGZK4CCGEEMJmSOIihBBCCJshiYsQQgghbIYkLkIIIYSwGZK4CCGEEMJmSOIihBBCCJshiYsQQgghbIYkLkKIm05CQgKzZ89usvslJydjMBhITk5usnsKIZqHJC5CCCGEsBlyyKIQ4qazfv16FEVp7jCEEDchSVyEEDcdOcRUCFEXGSoSQlxVTk4Ozz33HL1796ZTp04MHjyY1atXa9er55AkJSXx5ptvEhcXR3R0NNOnT+f06dNW9zpx4gRPPvkkcXFxREVFER8fT2JiIiaTSatT2xyXzMxMZs6cSY8ePejSpQujR4/mxx9/rBHrmTNnePzxx4mOjiY2NpZXX32V8vLyWl/X/v37efTRR+nWrRtdunThoYceYs+ePVZ1ioqKeOWVV0hISKBTp07ExsYyceJEDh061NhmFEI0AelxEULU6/z584wePRpFURg3bhze3t5s2bKF559/nqKiIh555BGt7uLFi1EUhSlTppCbm8snn3zCI488wpo1a3B2dqa8vJxHH32U8vJyHnroIVq1akVOTg4//vgjhYWFtGjRos4Yxo4dS2lpKQ8//DBeXl589dVXPPbYY/zrX//innvuAaCsrIwJEyZw+vRpHn74YXx9fVmzZg07duyocc/t27czZcoUOnXqxIwZM1AUhS+//JIJEybwn//8h86dOwMwd+5cNmzYwEMPPURISAgFBQXs2bOH1NRUIiMjm77BhRD1U4UQoh5z5sxR4+Li1Ly8PKvyxMREtVu3bmppaam6Y8cONSwsTL3jjjtUk8mk1UlKSlLDwsLUTz75RFVVVU1JSVHDwsLUdevW1ftv9uvXT501a5b2+JVXXlHDwsLUXbt2aWVFRUVqQkKC2q9fP7WqqkpVVVX9+OOP1bCwMDUpKUmrV1JSot5zzz1qWFiYumPHDlVVVdVsNqv33nuvOmnSJNVsNmt1S0tL1YSEBHXixIlaWbdu3dR58+Y1uL2EENeXDBUJIeqkqirfffcdCQkJqKpKXl6e9tenTx9MJpPVkMmIESNwd3fXHg8YMAAfHx82b94MoF37+eefKS0tbXAcmzdvpnPnzsTExGhlbm5ujBkzhuzsbI4fPw7Ali1b8PHxYcCAAVo9FxcXRo8ebXW/w4cPc+LECYYOHUp+fr72mkpKSoiNjWXXrl2YzWYA9Ho9+/fvJycnp8HxCiGuHxkqEkLUKS8vj8LCQr744gu++OKLOuvo9XoAAgMDra4pikJgYCDZ2dkAtG/fnokTJ/LRRx/xzTffEBMTQ0JCAsOGDatzmAjg1KlTdOnSpUZ5cHCwdj0sLIzs7GwCAwNrrEgKCgqyenzixAkAZs2aVee/aTKZ8PDw4JlnnmH27NnceeedREZG0rdvX0aMGEH79u3rfK4Q4vqRxEUIUafqXodhw4YxcuTIWusYDAatx6MhZs+ezciRI9m4cSNbt25lwYIF/Pvf/2blypW0bt26SeK+GlVVAXj22WcJDw+vtY6rqysAgwYNIiYmhu+//56tW7fywQcfsHTpUhYuXEjfvn1vSLxCiEskcRFC1Mnb2xs3NzfMZjO9e/eus1514pKRkWFVrqoqGRkZGAwGq3KDwYDBYODxxx9n7969PPDAAyxfvpzExMRa79+2bVvS09NrlKelpWnXAfz9/Tl69Ciqqlr1ulz53OreEnd393pfVzVfX1/GjRvHuHHjyM3NZeTIkSxZskQSFyGagcxxEULUyc7Ojv79+7NhwwaOHj1a43peXp7V46+//pqioiLt8fr16zl37hzx8fGAZWlxZWWl1XPCwsLQ6XR1LlkG6Nu3LwcOHGDfvn1aWUlJCStXrsTf35/Q0FAA4uPjOXv2LOvXr9fqlZaWsnLlSqv7derUiYCAAD788EOKi4vrfF1VVVVWy7QBWrZsia+vb73xCiGuH+lxEULU6y9/+QvJycmMHj2a+++/n9DQUIxGI4cOHWL79u3s3LlTq+vh4cGDDz7IqFGjtOXQgYGB2uTYHTt28PLLLzNgwAA6dOhAVVUVa9as0RKkukydOpW1a9cyZcoUHn74YTw8PPj666/Jyspi4cKF6HSW32CjR4/m888/Z9asWRw6dAgfHx9tKfbldDodCxYsYMqUKQwZMoRRo0bh5+dHTk4OycnJuLu7s2TJEoqLi+nbty/9+/enY8eOuLq6sm3bNg4ePNikZykJIRpOEhchRL1atWrFqlWrWLRoEd9//z3Lly/H09OT0NBQnnnmGau606dP58iRI7z33nsUFxcTGxvL3LlzcXFxASxDRH369GHTpk3k5OTg4uKCwWBg6dKlREdH1xvDihUr+Nvf/sayZcu4cOECBoOBJUuWcOedd2r1XFxc+Pjjj5k/fz7Lli3D2dmZoUOHEh8fz+TJk63u2bNnT7744gveffddli1bRklJCT4+PnTu3JkxY8YA4OzszAMPPMDWrVv57rvvUFWVgIAA5s6dy4MPPtg0DSyEaBRFrZ6lJoQQv1NycjLjx4/n7bfftlqKLIQQTU3muAghhBDCZkjiIoQQQgibIYmLEEIIIWyGzHERQgghhM2QHhchhBBC2AxJXIQQQghhMyRxEUIIIYTNkMRFCCGEEDZDEhchhBBC2AxJXIQQQghhMyRxEUIIIYTNkMRFCCGEEDbj/wDkci2zjYRH6QAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始测试！\n",
      "回合：1/20，奖励：200.00\n",
      "回合：2/20，奖励：200.00\n",
      "回合：3/20，奖励：200.00\n",
      "回合：4/20，奖励：200.00\n",
      "回合：5/20，奖励：200.00\n",
      "回合：6/20，奖励：200.00\n",
      "回合：7/20，奖励：200.00\n",
      "回合：8/20，奖励：200.00\n",
      "回合：9/20，奖励：200.00\n",
      "回合：10/20，奖励：200.00\n",
      "回合：11/20，奖励：200.00\n",
      "回合：12/20，奖励：200.00\n",
      "回合：13/20，奖励：200.00\n",
      "回合：14/20，奖励：200.00\n",
      "回合：15/20，奖励：200.00\n",
      "回合：16/20，奖励：200.00\n",
      "回合：17/20，奖励：200.00\n",
      "回合：18/20，奖励：200.00\n",
      "回合：19/20，奖励：200.00\n",
      "回合：20/20，奖励：200.00\n",
      "完成测试\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \n",
    "# 训练\n",
    "env, agent = env_agent_config(cfg)\n",
    "res_dic = train(cfg, env, agent)\n",
    " \n",
    "plot_rewards(res_dic['rewards'], cfg, tag=\"train\")  \n",
    "# 测试\n",
    "res_dic = test(cfg, env, agent)\n",
    "plot_rewards(res_dic['rewards'], cfg, tag=\"test\")  # 画出结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.13 ('joyrl')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "996e2c1bcfa8ebbd3aba48733c28d7658f0aec7cda7e9a0e5abbef50d3f90575"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
